<?php

/*
 * Controller/PlanningController.php
 */

namespace RHX\Controller;

use RHX\Helper\RHDateTime;
use RHX\Model\Object\XRules;
use RHX\Model\Object\Transfert;
use RHX\Helper\Number;

class PlanningController extends RHXController {

    public function indexAction() {
	// Table
	$siteTable	 = $this->getService('Table\SiteTable');
	$codeTable	 = $this->getService('Table\CodeActiviteTable');

	// Site
	$siteId	 = $this->params()
		->fromRoute('id', -1);
	// Affichage
	$refr	 = (int) $this->params()
			->fromRoute('other1', 0);
	$refresh = ($refr == 1) ? true : false;

	// Code d'activités
	$codeList	 = $codeTable->getAll('id ASC', true);
	// parcours des codes
	$codes		 = array();
	foreach ($codeList as $code) {
	    $codes[$code->code] = $code;
	}

	// Site à afficher
	$site = null;
	if ($siteId < 0) {
	    $site	 = $this->navigation->offsetGet('site');
	    $refresh = 1;
	}
	else {
	    $site = $siteTable->get($siteId);
	    $this->changeSite($siteId);
	}

	return array(
	    'site'		 => $site,
	    'codes'		 => $codes,
	    'refresh'	 => $refresh,
	);
    }

    public function loadIndexAction() {
	// Changement de layout
	$this->layout('layout/ajax');

	// Vue
	$planningListView	 = $this->getService('View\PSPlanningView');
	// tables
	$periodeSemaineTable	 = $this->getService('Table\PeriodeSemaineTable');
	$siteTable		 = $this->getService('Table\SiteTable');
	$periodeTable		 = $this->getService('Table\PeriodeTable');
	$planningSemaineTable	 = $this->getService('Table\PlanningSemaineTable');

	// Données en Post
	$post = $this->getRequest()
		->getPost();

	// Variables
	$siteId = $post->get('site');
	$this->changeSite($siteId);

	// Liste des Periodes
	$periodeList = $periodeTable->getAll('id DESC');

	// Variables
	$data = array();

	// Parcours de la liste des Périodes
	foreach ($periodeList as $periode) {
	    // Liste des Semaines d'une Période
	    $semaineList	 = $periodeSemaineTable->getSemainesByPeriode($periode->id, 'id DESC');
	    $semaines	 = array();
	    $plannings	 = array();

	    // Parcours des semaines de la période
	    foreach ($semaineList as $semaine) {
		$semaines[]		 = $semaine;
		$psPlanning		 = $planningListView->getOne($periode->id, $semaine->id, $siteId);
		$plannings[$semaine->id] = $psPlanning;
	    }

	    // Affectation
	    $data[] = array(
		'periode'	 => $periode,
		'semaines'	 => $semaines,
		'plannings'	 => $plannings,
	    );
	}

	// Site en Cours
	$site = $siteTable->get($siteId);

	return array(
	    'data'	 => $data,
	    'site'	 => $site,
	);
    }

    /**
     * Edition des plannings semaine
     * 
     * @return array
     */
    public function editAction() {
	// Changement de layout
	$this->layout('layout/ajax');

	// Variables en POST
	$post = $this->getRequest()
		->getPost();

	// Variables
	$siteId			 = $post->get('site_id');
	$lundi			 = $post->get('data-lundi');
	$template		 = $post->get('template');
	// Jours à aficher
	$daysOfWeek		 = array();
	// parcours des jours à afficher
	$daysOfWeek['lundi']	 = ($post->get('lundi') == 'on') ? true : false;
	$daysOfWeek['mardi']	 = ($post->get('mardi') == 'on') ? true : false;
	$daysOfWeek['mercredi']	 = ($post->get('mercredi') == 'on') ? true : false;
	$daysOfWeek['jeudi']	 = ($post->get('jeudi') == 'on') ? true : false;
	$daysOfWeek['vendredi']	 = ($post->get('vendredi') == 'on') ? true : false;
	$daysOfWeek['samedi']	 = ($post->get('samedi') == 'on') ? true : false;
	$daysOfWeek['dimanche']	 = ($post->get('dimanche') == 'on') ? true : false;

	// tables
	$planningSemaineTable	 = $this->getService('Table\PlanningSemaineTable');
	$employeTable		 = $this->getService('Table\EmployeTable');
	$codeTable		 = $this->getService('Table\CodeActiviteTable');
	$transfertTable		 = $this->getService('Table\TransfertTable');

	// Liste des employés
	//$employeList		 = $employeTable->getEmployesBySite($siteId);
	$dimanche		 = new RHDateTime($lundi);
	$dimanche->modify('next sunday');
	$employeList		 = $planningSemaineTable->getEmployeHavingPlanning($siteId, $lundi, $dimanche->date());
//	\Zend\Debug\Debug::dump($employeList, "Liste des employés");
	// parcours de la liste des employés
	$employes		 = array();
	$employeMatricule	 = array();
	$lastEmploye		 = null;
	foreach ($employeList as $employe) {
	    $employes[]		 = $employe;
	    $employeMatricule[]	 = $employe->matricule;
//	    \Zend\Debug\Debug::dump($employe->matricule, "Matricule");
	    $lastEmploye		 = $employe;
	}

	// Planning du Site
	$planningSemaine = $planningSemaineTable->getPlanningByEmploye($lundi, $employeMatricule);

	// parcours des plannings
	$plannings = array();
	foreach ($planningSemaine as $plan) {
	    $plannings[$plan->matricule] = $plan;
	}

	// Liste des codes d'activités
	$codeList	 = $codeTable->getAll();
	$codes		 = array();
	$codec		 = array();
	$colors		 = array();
	// Parcours de la liste des codes
	foreach ($codeList as $code) {
	    $codes[]		 = $code;
	    $codec[$code->id]	 = $code->code;
	    $colors[$code->id]	 = $code->libelle;
	}

	// Liste des Transfert pour le site
	if (!is_null($lastEmploye)) {
	    $entrantList	 = $transfertTable->getTransfert($lundi, $lastEmploye->site_id, 1);
	    $sortantList	 = $transfertTable->getTransfert($lundi, $lastEmploye->site_id, 2);

	    // Variables
	    $entrants	 = array();
	    $sortants	 = array();

	    // Parcours des entrants
	    foreach ($entrantList as $e) {
		$entrants[$e->matricule][$e->journee] = $e;
	    }
	    // Parcours des sortants
	    foreach ($sortantList as $s) {
		$sortants[$s->matricule][$s->journee] = $s;
	    }
	}

//	//echo '<pre>Entrants</pre>';
//	var_dump($entrants);
//	//echo '<pre>Sortants</pre>';
//	var_dump($sortants);
	// Editable
	$edit		 = $post->get('editable');
	$editable	 = ($edit == '1') ? true : false;

	// Liste des identifiants des semaines
	$tablePeriode	 = new \RHX\Model\Table\PeriodeTable($this->getAdapter());
	$periode	 = new \RHX\Model\Object\Periode($tablePeriode->getPeriodeByDate($lundi));
	$viewSemaine	 = new \RHX\Model\View\PSPlanningView($this->getAdapter());
	$semaines	 = $viewSemaine->getWeek($post->periode, $post->site_id);
	
	// Nombre de personne ideal sur site
	$tableIdeal = new \RHX\Model\Table\IdealTable($this->getAdapter());
	$tableSemaine = new \RHX\Model\Table\SemaineTable($this->getAdapter());
	$semaineEnCours = $tableSemaine->getSemaineByDate($post->get('data-lundi'));
	$ideals = $tableIdeal->getWeekIdeal($semaineEnCours, $post->site_id);
	
	$manager = new \RHX\Model\Manager\EmployeManager($this->getAdapter());

	return array(
	    'employes'		 => $employes,
	    'planningSemaine'	 => $planningSemaine,
	    'plannings'		 => $plannings,
	    'codes'			 => $codes,
	    'codec'			 => $codec,
	    'colors'		 => $colors,
	    'daysOfWeek'		 => $daysOfWeek,
	    'template'		 => $template,
	    'site'			 => (is_null($lastEmploye) || is_null($lastEmploye->site_id)) ? $post->site_id : $lastEmploye->site_id,
	    'adapter'		 => $codeTable->getAdapter(),
	    'lundi'			 => $lundi,
	    'editable'		 => $editable,
	    'entrants'		 => isset($entrants) ? $entrants : array(),
	    'sortants'		 => isset($sortants) ? $sortants : array(),
	    /*'siteObj'		 => (is_null($lastEmploye) || is_null($lastEmploye->site_id)) ? $manager->getSite($post->site_id) : $lastEmploye->getSite(),*/
            'siteObj'		 => $manager->getSite($post->site_id),
	    'post'			 => $post,
	    'periode'		 => $post->periode,
	    'semaine'		 => $post->semaine,
	    'semaines'		 => $semaines,
	    'ideals' => $ideals,
	);
    }

    /**
     * Afficher un POPIN
     * 
     * @return type
     */
    public function popinAction() {
	// Changement de layout
	$this->layout('layout/ajax');

	// Post
	$post = $this->getRequest()
		->getPost();

	// Variables
	$id	 = $post->get('id');
	$prefix	 = $post->get('prefix');

	// Tables
	$codeTable		 = $this->getService('Table\CodeActiviteTable');
	$planningSemaineTable	 = $this->getService('Table\PlanningSemaineTable');

	// Planning Semaine
	$planning = $planningSemaineTable->get($id);

	// Valeur à afficher
	$entree	 = '00:00';
	$sortie	 = '00:00';
	$code	 = 3;
	$repas	 = 0;
	$pause	 = 0;

	// Préparation des variables dynamiques
	$prefixCode	 = $prefix . '_code';
	$prefixEntree	 = $prefix . '_entree';
	$prefixSortie	 = $prefix . '_sortie';
	$prefixPause	 = $prefix . '_pause';
	$prefixRepas	 = $prefix . '_repas';

	// Assignation
	$code	 = $planning->$prefixCode;
	$entree	 = $planning->$prefixEntree;
	$sortie	 = $planning->$prefixSortie;
	$repas	 = $planning->$prefixRepas;
	$pause	 = $planning->$prefixPause;

	// Employé
	$emp = $planning->getEmploye();

	// Liste des codes d'activités
	$codeList	 = $codeTable->getSomeCodes($emp->getAncienneteValue());
	// Parcours des codes d'activités
	$codes		 = array();
	foreach ($codeList as $codec) {
	    $codes[$codec->id] = $codec;
	}

	// Données par défaut
	$dataCP		 = $emp->getDataCP();
	$debutDefaut	 = '08:00';

	$heureFin = new RHDateTime();
	$heureFin->setTime($debutDefaut);
	$heureFin->addHours($dataCP['heure']);

	// heure de référence
	$prefixEntreeRef = $prefixEntree . '_ref';
	$prefixSortieRef = $prefixSortie . '_ref';
	$entreeRef	 = $planning->$prefixEntreeRef;
	$sortieRef	 = $planning->$prefixSortieRef;
	if ($entreeRef == '00:00' || $entreeRef == '00:00:00' || $sortieRef == '00:00' || $sortieRef == '00:00:00') {
	    // On regarde maintenant dans les plannings type pour les références
	    $template	 = $planning->getTemplate();
	    $entreeRef	 = $template->$prefixEntree;
	    $sortieRef	 = $template->$prefixSortie;
	    // Test si dans le planning type les références d'heure sont à zéro
	    if ($entreeRef == '00:00' || $entreeRef == '00:00:00' || $sortieRef == '00:00' || $sortieRef == '00:00:00') {
		// Table Disponibilité
		$tableDisponibilite	 = new \RHX\Model\Table\EmployeDisponibiliteTable($this->getAdapter());
		$dispo			 = $tableDisponibilite->getDispoByEmploye($planning->matricule);
		$entreeRef		 = $dispo->$prefixEntree;
		$sortieRef		 = $dispo->$prefixSortie;
		// Test si dans les disponibilités les références d'heure sont à zéro
		if ($entreeRef == '00:00' || $entreeRef == '00:00:00' || $sortieRef == '00:00' || $sortieRef == '00:00:00') {
		    // On prend les heures des congés payés
		    $entreeRef	 = $debutDefaut;
		    $sortieRef	 = $heureFin->hours();
		}
	    }
	}

	// Identification des heures de retard ou de départ anticipé
	$dataPRDA = new \RHX\Model\Object\XData();
	if ((int) $code == XRules::ProblemeRetardDepartAnticipe) {
	    // Calculator
	    $calculator		 = new \RHX\Model\Object\XCalculator($this->getAdapter());
	    $template		 = $planning->getTemplate();
	    $template->$prefixEntree = $entreeRef;
	    $template->$prefixSortie = $sortieRef;
	    $dataPRDA		 = $calculator->calculateOneDay($planning, $template, $prefix);
	}

	return array(
	    'post'		 => $post,
	    'codes'		 => $codes,
	    'code'		 => $code,
	    'entree'	 => $entree,
	    'sortie'	 => $sortie,
	    'repas'		 => $repas,
	    'pause'		 => $pause,
	    'id'		 => $id,
	    'prefix'	 => $prefix,
	    'adapter'	 => $codeTable->getAdapter(),
	    'lundi'		 => $planning->lundi,
	    'site'		 => $emp->site_id,
	    'entreeDefaut'	 => $debutDefaut,
	    'sortieDefaut'	 => $heureFin->hours(),
	    'dureeCP'	 => $dataCP['heure'],
	    'employe'	 => $emp,
	    'entreeRef'	 => $entreeRef,
	    'sortieRef'	 => $sortieRef,
	    'dataPRDA'	 => $dataPRDA,
	);
    }

    public function saveAction() {
	// Changement de layout
	$this->layout('layout/ajax');

	// Données en post
	$post = $this->getRequest()
		->getPost();

	// tables
	$planningSemaineTable = $this->getService('Table\PlanningSemaineTable');

	// Variables
	$id	 = $post->get('id');
	$prefix	 = $post->get('prefix');
	$entree	 = $post->get('entree');
	$sortie	 = $post->get('sortie');
	$pause	 = $post->get('pause');
	$repas	 = $post->get('repas');
	$code	 = $post->get('code');

	// Planning Semaine
	$planning = $planningSemaineTable->get($id);

	// Assignation
	switch ($prefix) {
	    case 'lundi':
		$planning->lundi_code		 = $code;
		$planning->lundi_entree		 = $entree;
		$planning->lundi_sortie		 = $sortie;
		$planning->lundi_pause		 = $pause;
		$planning->lundi_repas		 = $repas;
		break;
	    case 'mardi':
		$planning->mardi_code		 = $code;
		$planning->mardi_entree		 = $entree;
		$planning->mardi_sortie		 = $sortie;
		$planning->mardi_pause		 = $pause;
		$planning->mardi_repas		 = $repas;
		break;
	    case 'mercredi':
		$planning->mercredi_code	 = $code;
		$planning->mercredi_entree	 = $entree;
		$planning->mercredi_sortie	 = $sortie;
		$planning->mercredi_pause	 = $pause;
		$planning->mercredi_repas	 = $repas;
		break;
	    case 'jeudi':
		$planning->jeudi_code		 = $code;
		$planning->jeudi_entree		 = $entree;
		$planning->jeudi_sortie		 = $sortie;
		$planning->jeudi_pause		 = $pause;
		$planning->jeudi_repas		 = $repas;
		break;
	    case 'vendredi':
		$planning->vendredi_code	 = $code;
		$planning->vendredi_entree	 = $entree;
		$planning->vendredi_sortie	 = $sortie;
		$planning->vendredi_pause	 = $pause;
		$planning->vendredi_repas	 = $repas;
		break;
	    case 'samedi':
		$planning->samedi_code		 = $code;
		$planning->samedi_entree	 = $entree;
		$planning->samedi_sortie	 = $sortie;
		$planning->samedi_pause		 = $pause;
		$planning->samedi_repas		 = $repas;
		break;
	    case 'dimanche':
		$planning->dimanche_code	 = $code;
		$planning->dimanche_entree	 = $entree;
		$planning->dimanche_sortie	 = $sortie;
		$planning->dimanche_pause	 = $pause;
		$planning->dimanche_repas	 = $repas;
		break;
	}

	// Heure non plannifié
	$calculator	 = new \RHX\Model\Object\XCalculator($this->getAdapter());
	$dataHNP	 = $calculator->getHeureNonPlannifie($planning->matricule, $planning->lundi);
	$template	 = $planning->getTemplate();
	$dataLundi	 = $calculator->calculateOneDay($planning, $template, 'lundi');
	$dataMardi	 = $calculator->calculateOneDay($planning, $template, 'mardi');
	$dataMercredi	 = $calculator->calculateOneDay($planning, $template, 'mercredi');
	$dataJeudi	 = $calculator->calculateOneDay($planning, $template, 'jeudi');
	$dataVendredi	 = $calculator->calculateOneDay($planning, $template, 'vendredi');
	$dataSamedi	 = $calculator->calculateOneDay($planning, $template, 'samedi');
	$dataDimanche	 = $calculator->calculateOneDay($planning, $template, 'dimanche');
	$dataWeek	 = $calculator->calculateWeek($dataLundi, $dataMardi, $dataMercredi, $dataJeudi, $dataVendredi, $dataSamedi, $dataDimanche);

	return new \Zend\View\Model\JsonModel(array(
	    'dataHNP'		 => $dataHNP,
	    'dataWeek'		 => $dataWeek,
	    'heureNonPlanifie'	 => $dataHNP['heureNonPlanifie'],
	    'heurePRDA'		 => $dataWeek['heurePRDA'],
	    'nbPRDA'		 => $dataWeek['nbPRDA'],
	));


//	return array(
//	    'post'		 => $post,
//	    'planning'	 => $planning,
//	);
    }

    /**
     * Heure Travaillées
     *
     * @return array
     */
    public function getHeureTravailleAction() {
	// Changement de layout
	$this->layout('layout/ajax');

	// Paramètre
	$id = (int) $this->params()->fromRoute('id', 0);

	// Variables
	$heureTravaille = 0;

	// tables
	$planningTable = $this->getService('Table\PlanningSemaineTable');

	if ($id != 0) {
	    $planning	 = $planningTable->get($id);
	    $heureTravaille	 = floatval($planning->heure_travaille);
	}

	return array(
	    'heureTravaille' => $heureTravaille,
	);
    }

    /**
     * Heure non planifiées
     * 
     * @return array
     */
    public function getHeureNonPlanifieAction() {
	// Changement de layout
	$this->layout('layout/ajax');

	// Paramètre
	$id = (int) $this->params()->fromRoute('id', 0);

	// Variables
	$heure = 0;

	// tables
	$planningTable = $this->getService('Table\PlanningSemaineTable');

	if ($id != 0) {
	    $planning	 = $planningTable->get($id);
	    $heure		 = floatval($planning->heure_non_planifie);
	}

	return array(
	    'heure'		 => $heure,
	    'id'		 => $id,
	    'planning'	 => $planning,
	);
    }

    public function getRetardAction() {
	// Changement de layout
	$this->layout('layout/ajax');

	// Paramètre
	$id = (int) $this->params()->fromRoute('id', 0);

	// Variables
	$retard		 = 0;
	$retardTime	 = '00:00';

	// Tables
	$planningTable = $this->getService('Table\PlanningSemaineTable');

	if ($id != 0) {
	    $planning	 = $planningTable->get($id);
	    $retard		 = (int) $planning->retard;
	    $retardTime	 = RHDateTime::hourNoSecond($planning->retard_heure);
	}

	return array(
	    'retard'	 => $retard,
	    'retardTime'	 => $retardTime,
	    'id'		 => $id,
	    'planning'	 => $planning,
	);
    }

    public function calculateHourAction() {
	// Changement de layout
	$this->layout('layout/ajax');

	// Calcul
	$this->calculateHour(null);
    }

    public function calculateHour($plList) {
	// Variables en POST
	//$plList = $this->getRequest()->getPost()->get('list');
	// tables
	$planningSemaineTable = $this->getService('Table\PlanningSemaineTable');

	$plannings = null;

	// Parcours des plannings
	if (is_array($plList)) {
	    // Liste des ID des plannings à mettre à jour
	    $plannings = $planningSemaineTable->getPlannings($plList);
	}
	else {
	    // Tous les plannings sont à metrre à jour
	    $plannings = $planningSemaineTable->getAll();
	}

	$rules = $this->getRules();

	$days = array(
	    'lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche',
	);

	foreach ($plannings as $planning) {
	    // Mise à jour des totals d'heure
	    $total		 = new RHDateTime();
	    $total->setTime();
	    $retard		 = 0;
	    $retardTime	 = new RHDateTime();
	    $retardTime->setTime();

	    // Calcul Heure Travaillé
	    for ($i = 0; $i < 7; $i++) {
		$day		 = $days[$i];
		$dayCode	 = $day . '_code';
		$dayEntree	 = $day . '_entree';
		$daySortie	 = $day . '_sortie';
		$diff		 = RHDateTime::diffHours($planning->$daySortie, $planning->$dayEntree);
		$code		 = (int) $planning->$dayCode;
		if ($rules->isCountable($code)) {
		    $total->addHours($diff, false);
		}
		if ($rules->isLate($code)) {
		    $retard++;
		    $retardTime->addHours($diff, false);
		}
	    }
//	    $diff	 = RHDateTime::diffHours($planning->lundi_entree, $planning->lundi_sortie);
//	    $code	 = (int) $planning->lundi_code;
//	    if ($rules->isCountable($code))
//		$total->addHours($diff, false);
//	    if ($rules->isLate($code)) {
//		$retard++;
//		$retardTime->addHours($diff, false);
//	    }
//	    $diff	 = RHDateTime::diffHours($planning->mardi_entree, $planning->mardi_sortie);
//	    $code	 = (int) $planning->mardi_code;
//	    if ($rules->isCountable($code))
//		$total->addHours($diff, false);
//	    if ($rules->isLate($code)) {
//		$retard++;
//		$retardTime->addHours($diff, false);
//	    }
//	    $diff	 = RHDateTime::diffHours($planning->mercredi_entree, $planning->mercredi_sortie);
//	    $code	 = (int) $planning->mercredi_code;
//	    if ($rules->isCountable($code))
//		$total->addHours($diff, false);
//	    if ($rules->isLate($code)) {
//		$retard++;
//		$retardTime->addHours($diff, false);
//	    }
//	    $diff	 = RHDateTime::diffHours($planning->jeudi_entree, $planning->jeudi_sortie);
//	    $code	 = (int) $planning->jeudi_code;
//	    if ($rules->isCountable($code))
//		$total->addHours($diff, false);
//	    if ($rules->isLate($code)) {
//		$retard++;
//		$retardTime->addHours($diff, false);
//	    }
//	    $diff	 = RHDateTime::diffHours($planning->vendredi_entree, $planning->vendredi_sortie);
//	    $code	 = (int) $planning->vendredi_code;
//	    if ($rules->isCountable($code))
//		$total->addHours($diff, false);
//	    if ($rules->isLate($code)) {
//		$retard++;
//		$retardTime->addHours($diff, false);
//	    }
//	    $diff	 = RHDateTime::diffHours($planning->samedi_entree, $planning->samedi_sortie);
//	    $code	 = (int) $planning->samedi_code;
//	    if ($rules->isCountable($code))
//		$total->addHours($diff, false);
//	    if ($rules->isLate($code)) {
//		$retard++;
//		$retardTime->addHours($diff, false);
//	    }
//	    $diff	 = RHDateTime::diffHours($planning->dimanche_entree, $planning->dimanche_sortie);
//	    $code	 = (int) $planning->dimanche_code;
//	    if ($rules->isCountable($code))
//		$total->addHours($diff, false);
//	    if ($rules->isLate($code)) {
//		$retard++;
//		$retardTime->addHours($diff, false);
//	    }
	    // Retard
	    $planning->retard	 = $retard;
	    $planning->retard_heure	 = $retardTime->totalHours();

	    // Heures Travaillé
	    $planning->heure_travaille = $total->totalHours();

	    // Employé
	    $employe		 = $planning->getEmploye();
	    // Avenant de l'employé
	    $avenant		 = $employe->getAvenant();
	    $hebdo_heure		 = (int) $avenant->hebdo;
	    $hebdo_minute		 = 0;
	    // Calcul des heures non planiffié
	    $diff_heure		 = 0;
	    $diff_minute		 = 0;
	    $travaille		 = explode(':', $planning->heure_travaille);
	    $travaille_heure	 = (int) $travaille[0];
	    $travaille_minute	 = (int) $travaille[1];
	    if ($travaille_minute >= $hebdo_minute) {
		// Calcul normal
		$diff_minute	 = $travaille_minute - $hebdo_minute;
		$diff_heure	 = $travaille_heure - $hebdo_heure;
	    }
	    else {
		// on enlève une heure
		$travaille_heure--;
		$travaille_minute += 60;
		$diff_minute	 = $travaille_minute - $hebdo_minute;
		$diff_heure	 = $travaille_heure - $travaille_heure;
	    }
	    $diff = "$diff_heure:$diff_minute";

	    // Heure non planninfié
	    $planning->heure_non_planifie = $diff;

	    // Sauvegarde dans la base de données
	    $planningSemaineTable->save($planning);
	}

	return array();
    }

    /**
     * Sélection des Templates
     *
     * @return array
     */
    public function selectTemplateAction() {
	// Changement de layout
	$this->layout('layout/ajax');

	// Données en POST
	$post = $this->getRequest()
		->getPost();

	// Site ID
	$id = $this->params()
		->fromRoute('id', 0);

	// tables
	$planningTemplateTable = $this->getService('Table\PlanningTemplateTable');

	// Liste des templates pour le site
	$templateList = $planningTemplateTable->getAllBySite($id);

	return array(
	    'list'		 => $templateList,
	    'periode_id'	 => $post->get('periode'),
	    'semaine_id'	 => $post->get('semaine'),
	    'template'	 => $post->get('template'),
	    'site_id'	 => $id,
	);
    }

    /**
     * Application du Template
     *
     * @return array
     */
    public function applyAction() {
	// Données en POST
	$post = $this->getRequest()
		->getPost();

	// Tables
	$planningPeriodeTable		 = $this->getService('Table\PlanningPeriodeTable');
	$planningSemaine		 = $this->getService('Table\PlanningSemaineTable');
	$semaineTable			 = $this->getService('Table\SemaineTable');
	$periodeTable			 = $this->getService('Table\PeriodeTable');
	$employeTemplateTable		 = $this->getService('Table\EmployeTemplateTable');
	//$tableEmploye		 = new \RHX\Model\Table\EmployeTable($this->getAdapter());
	// Enregistrement dans le Planning Periode
	$planningPeriode		 = new \RHX\Model\Object\PlanningPeriode();
	$planningPeriode->periode_id	 = $post->get('periode_id');
	$planningPeriode->template	 = $post->get('template');
	$planningPeriode->semaine_id	 = $post->get('semaine_id');
	$planningPeriodeTable->save($planningPeriode);

	/* Génération du Planning Semaines */
	// Liste des Templates au template donnée
	$templateList = $employeTemplateTable->getTemplates($post->get('template'));

	// Semaine donnée
	$semaine = $semaineTable->get($post->get('semaine_id'));

	// Parcours des Templates
	$templates	 = array();
	$plannings	 = array();
	$lastMatricule	 = 0;
	$days		 = array(
	    'lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche',
	);
	$prorata	 = array('float' => -1.0, 'time' => '00:00');
	foreach ($templateList as $tpl) {
	    $planning		 = new \RHX\Model\Object\PlanningSemaine($planningSemaine->getAdapter());
	    //\Zend\Debug\Debug::dump($planning, 'Planning');
	    // employe en cours
	    $employe		 = $tpl->getEmploye();
	    $dateEntree		 = new RHDateTime($employe->contrat_debut);
	    $isDateDepartEmpty	 = $employe->contrat_fin === null || $employe->contrat_fin === '' || $employe->contrat_fin === '0000-00-00';
	    $dateDepart		 = !$isDateDepartEmpty ? new RHDateTime($employe->contrat_fin) : null;
	    $periodePlanning	 = $periodeTable->get($post->periode_id);
	    //\Zend\Debug\Debug::dump($periodePlanning, 'Periode en cours');
	    $periodeDebut		 = new RHDateTime($periodePlanning->debut);
	    $periodeFin		 = new RHDateTime($periodePlanning->fin);

	    if ($periodeFin->isLT($dateEntree)) { // periode est avant date entrée
		// ne fait rien, ne sauvegarde rien
	    }
	    elseif (!$isDateDepartEmpty && $periodeDebut->isGT($dateDepart)) {    // periode est après date depart            
		// ne fait rien, ne sauvegarde rien
	    }
	    else {
		////echo "EMP CONTRAT CHEVAUCHE PERIODE ".$employe->matricule ." -{ {$employe->contrat_debut} à {$employe->contrat_fin} }"."<br> ";
		for ($i = 0; $i < 7; $i++) {
		    $day		 = $days[$i];
		    $dayCode	 = $day . '_code';
		    $dayEntree	 = $day . '_entree';
		    $daySortie	 = $day . '_sortie';
		    $dayPause	 = $day . '_pause';
		    $dayRepas	 = $day . '_repas';
		    $planning->$day	 = $semaine->$day;
		    $jour		 = new RHDateTime($planning->$day);
		    ////echo "<pre>Date d'entrée : {$dateEntree->date()}, Jour : {$jour->date()}</pre>";
		    if ($dateEntree->isBetween($periodeDebut, $periodeFin)) {
			////echo "<pre>La date d'entrée est entre les date de début et de fin de la période {$periodeDebut->date()} à {$periodeFin->date()}</pre>";
			if (($dateEntree->isLT($jour) || $dateEntree->isEqual($jour) ) && ($isDateDepartEmpty || ($dateDepart->isGT($jour) || $dateDepart->isEqual($jour) ) )) {
			    //si jour est entre la date d'entrée et de sortie et si, éventuellement, pas de date de depart => CODE TEMPLATE</pre>";
			    //echo(" daycode <br>");
			    $planning->$dayCode	 = $tpl->$dayCode;
			    $planning->$dayEntree	 = $tpl->$dayEntree;
			    $planning->$daySortie	 = $tpl->$daySortie;
			    $planning->$dayPause	 = $tpl->$dayPause;
			    $planning->$dayRepas	 = $tpl->$dayRepas;
			}
			else {
			    ////echo "<pre>Jour n'est pas compris entre entrée et depart => CODE ES</pre>";
			    // //echo(" daycode <br>");
			    $planning->$dayCode	 = XRules::EntreeSortie;
			    $planning->$dayEntree	 = "00:00";
			    $planning->$daySortie	 = "00:00";
			    $planning->$dayPause	 = 0;
			    $planning->$dayRepas	 = 0;
			    $calculator		 = new \RHX\Model\Object\XCalculator($this->getAdapter());
			    $prorata		 = $calculator->prorataHeurePrevues($tpl->heure_prevues, $day);
			}
		    }
		    else {  //date entrée < debut periode seulement(le cas où date entrée > finperdiode est exclu en haut )
			// seule la fin de periode determine le parm du jour 
			//echo("<br>date entrée < debut periode<br>");
			/* obsolete : //echo "<pre>La date d'entrée n'est entre les date de début et de fin de la période {$periodeDebut->date()} à {$periodeFin->date()}</pre>";
			  if ($dateEntree->isGT($periodeFin)  ) {
			  // On ne fait rien puisqu'il n'est pas dans l'entreprise pour cette période
			  ////echo "<pre>On ne fait rien</pre>";
			  }
			  else {
			  // Affectation template
			  ////echo "<pre>Affectation template car la date d'entrée est supérieur à la date du jour mais inférieur à la date de fin de la période</pre>";
			  $planning->$dayCode	 = $tpl->$dayCode;
			  $planning->$dayEntree	 = $tpl->$dayEntree;
			  $planning->$daySortie	 = $tpl->$daySortie;
			  $planning->$dayPause	 = $tpl->$dayPause;
			  $planning->$dayRepas	 = $tpl->$dayRepas;
			  } */

			if ($isDateDepartEmpty || $jour->isLT($dateDepart) || $jour->isEqual($dateDepart)) {
			    //echo(" daycode <br>");
			    $planning->$dayCode	 = $tpl->$dayCode;
			    $planning->$dayEntree	 = $tpl->$dayEntree;
			    $planning->$daySortie	 = $tpl->$daySortie;
			    $planning->$dayPause	 = $tpl->$dayPause;
			    $planning->$dayRepas	 = $tpl->$dayRepas;
			}
			else {
			    //echo(" ES<br>");
			    $planning->$dayCode	 = XRules::EntreeSortie;
			    $planning->$dayEntree	 = "00:00";
			    $planning->$daySortie	 = "00:00";
			    $planning->$dayPause	 = 0;
			    $planning->$dayRepas	 = 0;
			    $calculator		 = new \RHX\Model\Object\XCalculator($this->getAdapter());
			    $prorata		 = $calculator->prorataHeurePrevues($tpl->heure_prevues, $day);
			}
		    }
		}


		// Heures Prévues
		if ($prorata['float'] < 0.0) {
		    $planning->heure_prevues = $tpl->heure_prevues;
		}
		else {
		    $planning->heure_prevues = $prorata['time'];
		}

		// Matricule
		$planning->matricule	 = $tpl->matricule;
		

		// Sauvegarde
		$plannings[] = $planningSemaine->save($planning);
	    } // end if 
            
            $lastMatricule		 = $employe->matricule;
	} // end foreach

       
	// Employé du dernier matricule
	$employe = $this->getService('Table\EmployeTable')->get($lastMatricule);

	// Calcul des heures
        if(count($plannings))
            $this->calculateHour($plannings);

	// Manager de template
	$templateManager = new \RHX\Model\Manager\TemplateManager($this->getAdapter());
	$data		 = $templateManager->duplicateTemplate($post->template);

	//return array();

	return $this->redirect()
			->toRoute('RHX/default', array('controller' => 'planning', 'action' => 'index', 'id' => $employe->site_id, 'other1' => 1));
    }

    /**
     * Sélection de Template pour remplacement
     * 
     * @return array
     */
    public function selectChangeTemplateAction() {
	// Changement de layout
	$this->layout('layout/ajax');

	// Données en POST
	$post = $this->getRequest()
		->getPost();

	// Site ID
	$id = $this->params()
		->fromRoute('id', 0);

	// tables
	$planningTemplateTable = $this->getService('Table\PlanningTemplateTable');

	// Liste des templates pour le site
	$templateList = $planningTemplateTable->getAllBySite($id);

	return array(
	    'list'		 => $templateList,
	    'periode_id'	 => $post->get('periode'),
	    'semaine_id'	 => $post->get('semaine'),
	    'template'	 => $post->get('template'),
	    'site_id'	 => $id,
	    'pl_id'		 => $post->get('pl_id'),
	);
    }

    public function applyChangeAction() {
	// Données en POST
	$post = $this->getRequest()
		->getPost();

	// tables
	$planningPeriodeTable	 = $this->getService('Table\PlanningPeriodeTable');
	$planningSemaineTable	 = $this->getService('Table\PlanningSemaineTable');
	$semaineTable		 = $this->getService('Table\SemaineTable');
	$periodeTable		 = $this->getService('Table\PeriodeTable');
	$employeTemplateTable	 = $this->getService('Table\EmployeTemplateTable');
	$employeTable		 = $this->getService('Table\EmployeTable');

	// Liste des employés du site
	$siteId		 = $post->get('site');
	$employes	 = $employeTable->getEmployesBySite($siteId);

	// Semaine
	$semaineId	 = $post->get('semaine_id');
	$semaine	 = $semaineTable->get($semaineId);

	// Template NUM
	$templateNum	 = $post->get('template');
	$dayName	 = array(
	    'lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche',
	);

	foreach ($employes as $e) {
	    // Récupération du planning semaine de l'employé
	    $plSemaine	 = $planningSemaineTable->getByEmploye($e->matricule, $semaine->lundi);
	    // Récupération du template de l'employé
	    $template	 = $employeTemplateTable->getEmployeTemplate($e->matricule, $templateNum);

	    // Date d'entrée de l'employé
	    $dateEntree = new RHDateTime($e->contrat_debut);

	    // Periode du planning
	    $periodePlanning = new \RHX\Model\Object\Periode($periodeTable->getPeriodeByDate($plSemaine->lundi));
	    $periodeDebut	 = new RHDateTime($periodePlanning->debut);
	    $periodeFin	 = new RHDateTime($periodePlanning->fin);

	    for ($i = 0; $i < 7; $i++) {
		$day		 = $dayName[$i];
		$dayCode	 = $day . '_code';
		$dayEntree	 = $day . '_entree';
		$daySortie	 = $day . '_sortie';
		$dayPause	 = $day . '_pause';
		$dayRepas	 = $day . '_repas';
		$jour		 = new RHDateTime($plSemaine->$day);

		if ($dateEntree->isBetween($periodeDebut, $periodeFin)) {
		    if ($dateEntree->isLT($jour) || $dateEntree->isEqual($jour)) {
			$plSemaine->$dayCode	 = $template->$dayCode;
			$plSemaine->$dayEntree	 = $template->$dayEntree;
			$plSemaine->$daySortie	 = $template->$daySortie;
			$plSemaine->$dayPause	 = $template->$dayPause;
			$plSemaine->$dayRepas	 = $template->$dayRepas;
		    }
		    else {
			$plSemaine->$dayCode	 = XRules::EntreeSortie;
			$plSemaine->$dayEntree	 = "00:00";
			$plSemaine->$daySortie	 = "00:00";
			$plSemaine->$dayPause	 = 0;
			$plSemaine->$dayRepas	 = 0;
		    }
		}
		else {
		    if ($dateEntree->isGT($periodeFin)) {
			// on ne fait rien car le ES n'est valable que pour la période en cours
		    }
		    elseif ($dateEntree->isLT($periodeDebut)) {
			// Affectation de template
			$plSemaine->$dayCode	 = $template->$dayCode;
			$plSemaine->$dayEntree	 = $template->$dayEntree;
			$plSemaine->$daySortie	 = $template->$daySortie;
			$plSemaine->$dayPause	 = $template->$dayPause;
			$plSemaine->$dayRepas	 = $template->$dayRepas;
		    }
		}
	    }

	    // heures prévues
	    $plSemaine->heure_prevues = $template->heure_prevues;

	    // Sauvegarde
	    //var_dump($plSemaine);
	    $planningSemaineTable->save($plSemaine);
	}

	// Enregistrement dans les Plannings Periodes
	$planningPeriodeId		 = $post->get('pl_id');
	$planningPeriode		 = $planningPeriodeTable->get($planningPeriodeId);
	$planningPeriode->template	 = $templateNum;
	$planningPeriodeTable->save($planningPeriode);

	// redirection
	$this->redirect()
		->toRoute('RHX/default', array('controller' => 'planning'));
    }

    public function calculSyntheseAction() {
	// GET
	$query = $this->getRequest()
		->getQuery();

	// Site
	$siteId = $query->site;

	// Lundi
	$lundi = $query->lundi;

	// Préfixe
	$prefix = $query->prefix;

	// Table
	$employeTable	 = $this->getService('Table\EmployeTable');
	$planningTable	 = $this->getService('Table\PlanningSemaineTable');

	// Liste des employés du Site
	$employeList	 = $employeTable->getEmployesBySite($siteId);
	// Parcours des employés
	$employes	 = array();
	$emp		 = array();
	foreach ($employeList as $e) {
	    $employes[]		 = $e->matricule;
	    $emp[$e->matricule]	 = $e;
	}

	// Planning Semaine correspondant
	$plannings = $planningTable->getPlanningByEmploye($lundi, $employes);

	// Parcours des plannings
	$heureTravaille	 = new RHDateTime();
	$heureTravaille->setTime();
//	//echo "Initialisation : " . $heureTravaille->totalHours() . "\n";
	$MOSite		 = 0.0;
	$MOEntrant	 = 0.0;
	$MOSortant	 = 0.0;
	$pause		 = '00:30';
	$days		 = array(
	    'lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche',
	);
	foreach ($plannings as $pl) {
	    // Employe
	    $e	 = $emp[$pl->matricule];
	    $coef	 = $e->getCoefficient();
	    $avenant = $e->getAvenant();
	    $taux	 = floatval($avenant->taux);
	    // Test Prefix
	    switch ($prefix) {

		case 'lundi':
		    // Test du code
		    $diff = RHDateTime::diffHours($pl->lundi_entree, $pl->lundi_sortie);
		    if ((int) $pl->lundi_pause == 1) {
			$diff = RHDateTime::diffHours($diff, $pause, false);
		    }
		    switch ((int) $pl->lundi_code) {
			case XRules::Present:
			case XRules::ProblemeRetardDepartAnticipe:
			    // Heure Travaillé Sur site
			    $heureTravaille->addHours($diff, false);
			    // Main d'oeuvre sur Site
			    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
			    $MOSite += $mo;
			    break;
			case XRules::TransfertEntrant:
			    // Heure Travaillé Sur site
			    $heureTravaille->addHours($diff, false);
			    // Main d'oeuvre sur Site
			    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
			    $MOSite += $mo;
			    // Main d'oeuvre sur Transfert Entrant
			    $MOEntrant += $mo;
			    break;
			case XRules::TransfertSortant:
			    // Main d'oeuvre sur Transfert Sortant
			    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
			    $MOSortant += $mo;
			    break;
		    }
		    break;

		case 'mardi':
		    // Test du code
		    $diff = RHDateTime::diffHours($pl->mardi_sortie, $pl->mardi_entree);
		    if ((int) $pl->mardi_pause == 1) {
			$diff = RHDateTime::diffHours($diff, $pause);
		    }
		    switch ((int) $pl->mardi_code) {
			case XRules::Present:
			case XRules::ProblemeRetardDepartAnticipe:
			    // Heure Travaillé Sur site
			    $heureTravaille->addHours($diff, false);
			    // Main d'oeuvre sur Site
			    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
			    $MOSite += $mo;
			    break;
			case XRules::TransfertEntrant:
			    // Heure Travaillé Sur site
			    $heureTravaille->addHours($diff, false);
			    // Main d'oeuvre sur Site
			    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
			    $MOSite += $mo;
			    // Main d'oeuvre sur Transfert Entrant
			    $MOEntrant += $mo;
			    break;
			case XRules::TransfertSortant:
			    // Main d'oeuvre sur Transfert Sortant
			    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
			    $MOSortant += $mo;
			    break;
		    }
		    break;

		case 'mercredi':
		    // Test du code
		    $diff = RHDateTime::diffHours($pl->mercredi_sortie, $pl->mercredi_entree);
//		    //echo "Avant : $diff\n";
		    if ((int) $pl->mercredi_pause == 1) {
			$diff = RHDateTime::diffHours($diff, $pause);
		    }
//		    //echo "Après : $diff\n";
		    switch ((int) $pl->mercredi_code) {
			case XRules::Present:
			case XRules::ProblemeRetardDepartAnticipe:
			    // Heure Travaillé Sur site
			    $heureTravaille->addHours($diff, false);
//			    //echo "Addition : " . $heureTravaille->totalHours() . "\n";
			    // Main d'oeuvre sur Site
			    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
			    $MOSite += $mo;
			    break;
			case XRules::TransfertEntrant:
			    // Heure Travaillé Sur site
			    $heureTravaille->addHours($diff, false);
			    // Main d'oeuvre sur Site
			    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
			    $MOSite += $mo;
			    // Main d'oeuvre sur Transfert Entrant
			    $MOEntrant += $mo;
			    break;
			case XRules::TransfertSortant:
			    // Main d'oeuvre sur Transfert Sortant
			    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
			    $MOSortant += $mo;
			    break;
		    }
		    break;

		case 'jeudi':
		    // Test du code
		    $diff = RHDateTime::diffHours($pl->jeudi_sortie, $pl->jeudi_entree);
		    if ((int) $pl->jeudi_pause == 1) {
			$diff = RHDateTime::diffHours($diff, $pause);
		    }
		    switch ((int) $pl->jeudi_code) {
			case XRules::Present:
			case XRules::ProblemeRetardDepartAnticipe:
			    // Heure Travaillé Sur site
			    $heureTravaille->addHours($diff, false);
			    // Main d'oeuvre sur Site
			    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
			    $MOSite += $mo;
			    break;
			case XRules::TransfertEntrant:
			    // Heure Travaillé Sur site
			    $heureTravaille->addHours($diff, false);
			    // Main d'oeuvre sur Site
			    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
			    $MOSite += $mo;
			    // Main d'oeuvre sur Transfert Entrant
			    $MOEntrant += $mo;
			    break;
			case XRules::TransfertSortant:
			    // Main d'oeuvre sur Transfert Sortant
			    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
			    $MOSortant += $mo;
			    break;
		    }
		    break;

		case 'vendredi':
		    // Test du code
		    $diff = RHDateTime::diffHours($pl->vendredi_sortie, $pl->vendredi_entree);
		    if ((int) $pl->vendredi_pause == 1) {
			$diff = RHDateTime::diffHours($diff, $pause);
		    }
		    switch ((int) $pl->vendredi_code) {
			case XRules::Present:
			case XRules::ProblemeRetardDepartAnticipe:
			    // Heure Travaillé Sur site
			    $heureTravaille->addHours($diff, false);
			    // Main d'oeuvre sur Site
			    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
			    $MOSite += $mo;
			    break;
			case XRules::TransfertEntrant:
			    // Heure Travaillé Sur site
			    $heureTravaille->addHours($diff, false);
			    // Main d'oeuvre sur Site
			    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
			    $MOSite += $mo;
			    // Main d'oeuvre sur Transfert Entrant
			    $MOEntrant += $mo;
			    break;
			case XRules::TransfertSortant:
			    // Main d'oeuvre sur Transfert Sortant
			    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
			    $MOSortant += $mo;
			    break;
		    }
		    break;

		case 'samedi':
		    // Test du code
		    $diff = RHDateTime::diffHours($pl->samedi_sortie, $pl->samedi_entree);
		    if ((int) $pl->samedi_pause == 1) {
			$diff = RHDateTime::diffHours($diff, $pause);
		    }
		    switch ((int) $pl->samedi_code) {
			case XRules::Present:
			case XRules::ProblemeRetardDepartAnticipe:
			    // Heure Travaillé Sur site
			    $heureTravaille->addHours($diff, false);
			    // Main d'oeuvre sur Site
			    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
			    $MOSite += $mo;
			    break;
			case XRules::TransfertEntrant:
			    // Heure Travaillé Sur site
			    $heureTravaille->addHours($diff, false);
			    // Main d'oeuvre sur Site
			    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
			    $MOSite += $mo;
			    // Main d'oeuvre sur Transfert Entrant
			    $MOEntrant += $mo;
			    break;
			case XRules::TransfertSortant:
			    // Main d'oeuvre sur Transfert Sortant
			    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
			    $MOSortant += $mo;
			    break;
		    }
		    break;

		case 'dimanche':
		    // Test du code
		    $diff = RHDateTime::diffHours($pl->dimanche_sortie, $pl->dimanche_entree);
		    if ((int) $pl->dimanche_pause == 1) {
			$diff = RHDateTime::diffHours($diff, $pause);
		    }
		    switch ((int) $pl->dimanche_code) {
			case XRules::Present:
			case XRules::ProblemeRetardDepartAnticipe:
			    // Heure Travaillé Sur site
			    $heureTravaille->addHours($diff, false);
			    // Main d'oeuvre sur Site
			    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
			    $MOSite += $mo;
			    break;
			case XRules::TransfertEntrant:
			    // Heure Travaillé Sur site
			    $heureTravaille->addHours($diff, false);
			    // Main d'oeuvre sur Site
			    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
			    $MOSite += $mo;
			    // Main d'oeuvre sur Transfert Entrant
			    $MOEntrant += $mo;
			    break;
			case XRules::TransfertSortant:
			    // Main d'oeuvre sur Transfert Sortant
			    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
			    $MOSortant += $mo;
			    break;
		    }
		    break;
	    }
	}
	$totalHours = RHDateTime::toFloat($heureTravaille->totalHours());

	// Transferts Entrant sur le site en cours
	$transfertTable		 = $this->getService("Table\TransfertTable");
	$transfertEntrants	 = $transfertTable->getTransfert($lundi, $siteId, 1);
	foreach ($transfertEntrants as $transfert) {
	    $nomJour = RHDateTime::dayName($transfert->journee);
	    if ($nomJour == $prefix) {
		$diff	 = RHDateTime::diffHours($transfert->sortie, $transfert->entree);
		$employe = $transfert->getEmploye();
		$coef	 = $employe->getCoefficient();
		$avenant = $employe->getAvenant();
		$taux	 = floatval($avenant->taux);
		$mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
		$MOEntrant += $mo;
		//$transfertEntrant++;
	    }
	}


//	//echo "Heure Total (float) : $totalHours\n";
//	//echo "Heure : " . $heureTravaille->totalHours() . "\n";
	$resultat = array(
	    'heures'	 => number_format($totalHours, 2, ',', ' '),
	    'site'		 => number_format($MOSite, 2, ',', ' '),
	    'entrant'	 => number_format($MOEntrant, 2, ',', ' '),
	    'sortant'	 => number_format($MOSortant, 2, ',', ' '),
	);

	return new \Zend\View\Model\JsonModel($resultat);
    }

    /**
     * Vérification des heures
     * 
     * @return \Zend\View\Model\JsonModel
     */
    public function verifyHourAction() {
	// changement de layout
	$this->layout('layout/ajax');

	// Post
	$post = $this->getRequest()
		->getPost();

	// Variables
	$e	 = $post->get('entree');
	$s	 = $post->get('sortie');

	// Temporelle
	$entree		 = new RHDateTime();
	$entree->setTime($e);
	$sortie		 = new RHDateTime();
	$sortie->setTime($s);
	$diff		 = new RHDateTime();
	$d		 = RHDateTime::diffHours($s, $e);
	$diff->setTime($d);
	$reference	 = new RHDateTime();
	$reference->setTime('05:00:00');
	$h12		 = new RHDateTime();
	$h12->setTime('12:00:00');
	$h14		 = new RHDateTime();
	$h14->setTime('14:00:00');

	$repas	 = false;
	$pause	 = false;

	// Temps de travail
	if ($diff->isGT($reference)) {
	    $pause = true;
	}

	// Entre 12h - 14h
	if ($h12->isBetween($entree, $sortie)) {
	    $repas = true;
	}
	if ($h14->isBetween($entree, $sortie)) {
	    $repas = true;
	}

	// Heure de sortie
	$sortieHeure	 = (int) $entree->getH();
	$sortieHeure++;
	$affHeure	 = '';
	for ($i = $sortieHeure; $i < 24; $i++) {
	    $affI = ($i < 0) ? '0' . $i : $i;
	    $affHeure .= "<option value='$affI'>$affI</option>\n";
	}

	return new \Zend\View\Model\JsonModel(array(
	    'repas'		 => $repas,
	    'pause'		 => $pause,
	    'sortieHeure'	 => $sortieHeure,
	    'heureSortie'	 => $affHeure,
	));
    }

    public function jsonGetLateDataAction() {
	// Règles
	$rules = new XRules($this->getAdapter());

	// GET
	$get = $this->getRequest()
		->getQuery();

	// Variables
	$planningId	 = $get->id;
	$code		 = $get->code;
	$entree		 = $get->entree;
	$sortie		 = $get->sortie;
	$prefix		 = $get->prefix;

	// Tables
	$planningTable = $this->getService('Table\PlanningSemaineTable');

	// Planning
	$planning = $planningTable->get($planningId);

	// Template
	$template = $this->getService('View\PSPlanningView')
		->getTemplate($planning->id, $planning->matricule);

	// Etat
	$state = null;

	// Identification du Jour
	switch ($prefix) {

	    case 'lundi':
		$state = $rules->calculateLateState($code, $entree, $sortie, $template->lundi_entree, $template->lundi_sortie);
		break;

	    case 'mardi':
		$state = $rules->calculateLateState($code, $entree, $sortie, $template->mardi_entree, $template->mardi_sortie);
		break;

	    case 'mercredi':
		$state = $rules->calculateLateState($code, $entree, $sortie, $template->mercredi_entree, $template->mercredi_sortie);
		break;

	    case 'jeudi':
		$state = $rules->calculateLateState($code, $entree, $sortie, $template->jeudi_entree, $template->jeudi_sortie);
		break;

	    case 'vendredi':
		$state = $rules->calculateLateState($code, $entree, $sortie, $template->vendredi_entree, $template->vendredi_sortie);
		break;

	    case 'samedi':
		$state = $rules->calculateLateState($code, $entree, $sortie, $template->samedi_entree, $template->samedi_sortie);
		break;

	    case 'dimanche':
		$state = $rules->calculateLateState($code, $entree, $sortie, $template->dimanche_entree, $template->dimanche_sortie);
		break;
	}

	return new \Zend\View\Model\JsonModel($state);
    }

    public function verifyPresenceAction() {
	// GET
	$query = $this->getRequest()
		->getQuery();

	// Site
	$siteId = $query->site;

	// Lundi
	$lundi	 = $query->lundi;
	$lundi	 = new RHDateTime($lundi);

	// Heure de référence
	$ref = $query->value;

	// Temps
	$refHeure = new RHDateTime();
	$refHeure->setTime($ref);

	// Tables
	$employeTable	 = $this->getService('Table\EmployeTable');
	$planningTable	 = $this->getService('Table\PlanningSemaineTable');

	// Liste des employés du site
	$employeList	 = $employeTable->getEmployesBySite($siteId);
	// Parcours des employés
	$employes	 = array();
	foreach ($employeList as $e) {
	    $employes[] = $e->matricule;
	}

	// Planning Semaine correspondant
	$plannings = $planningTable->getPlanningByEmploye($lundi->date(), $employes);

	// Parcours des plannings
	$lundiPresence		 = 0;
	$mardiPresence		 = 0;
	$mercrediPresence	 = 0;
	$jeudiPresence		 = 0;
	$vendrediPresence	 = 0;
	$samediPresence		 = 0;
	$dimanchePresence	 = 0;
	$daysOfWeek		 = array();
	$cp			 = 0;
	foreach ($plannings as $pl) {
	    // Test par date du lundi à dimanche
	    // lundi
	    $code = (int) $pl->lundi_code;
	    if ($code == XRules::CongePaye) {
		$cp++;
	    }
	    if ($code == XRules::Present || XRules::ProblemeRetardDepartAnticipe || XRules::EcoleFormationEmploye || XRules::EcoleFormationAlternance || XRules::EcoleFormationIntegration || XRules::Ferie1 || XRules::Ferie2 || XRules::Ferie3) {
		$lundiEntree	 = new RHDateTime();
		$lundiEntree->setTime($pl->lundi_entree);
		$lundiSortie	 = new RHDateTime();
		$lundiSortie->setTime($pl->lundi_sortie);
		if ($refHeure->isBetween($lundiEntree, $lundiSortie)) {
		    $lundiPresence++;
		}
	    }

	    // mardi
	    $code = (int) $pl->mardi_code;
	    if ($code == XRules::CongePaye) {
		$cp++;
	    }
	    if ($code == XRules::Present || $code == XRules::ProblemeRetardDepartAnticipe || $code == XRules::EcoleFormationEmploye || $code == XRules::EcoleFormationAlternance || $code == XRules::EcoleFormationIntegration || $code == XRules::Ferie1 || $code == XRules::Ferie2 || $code == XRules::Ferie3) {
		$mardiEntree	 = new RHDateTime();
		$mardiEntree->setTime($pl->mardi_entree);
		$mardiSortie	 = new RHDateTime();
		$mardiSortie->setTime($pl->mardi_sortie);
		if ($refHeure->isBetween($mardiEntree, $mardiSortie)) {
		    $mardiPresence++;
		}
		if ($code == XRules::CongePaye) {
		    $cp++;
		}
	    }

	    // mercredi
	    $code = (int) $pl->mercredi_code;
	    if ($code == XRules::CongePaye) {
		$cp++;
	    }
	    if ($code == XRules::Present || $code == XRules::ProblemeRetardDepartAnticipe || $code == XRules::EcoleFormationEmploye || $code == XRules::EcoleFormationAlternance || $code == XRules::EcoleFormationIntegration || $code == XRules::Ferie1 || $code == XRules::Ferie2 || $code == XRules::Ferie3) {
		$mercrediEntree	 = new RHDateTime();
		$mercrediEntree->setTime($pl->mercredi_entree);
		$mercrediSortie	 = new RHDateTime();
		$mercrediSortie->setTime($pl->mercredi_sortie);
		if ($refHeure->isBetween($mercrediEntree, $mercrediSortie)) {
		    $mercrediPresence++;
		}
	    }

	    // jeudi
	    $code = (int) $pl->jeudi_code;
	    if ($code == XRules::CongePaye) {
		$cp++;
	    }
	    if ($code == XRules::Present || $code == XRules::ProblemeRetardDepartAnticipe || $code == XRules::EcoleFormationEmploye || $code == XRules::EcoleFormationAlternance || $code == XRules::EcoleFormationIntegration || $code == XRules::Ferie1 || $code == XRules::Ferie2 || $code == XRules::Ferie3) {
		$jeudiEntree	 = new RHDateTime();
		$jeudiEntree->setTime($pl->jeudi_entree);
		$jeudiSortie	 = new RHDateTime();
		$jeudiSortie->setTime($pl->jeudi_sortie);
		if ($refHeure->isBetween($jeudiEntree, $jeudiSortie)) {
		    $jeudiPresence++;
		}
	    }

	    // vendredi
	    $code = (int) $pl->vendredi_code;
	    if ($code == XRules::CongePaye) {
		$cp++;
	    }
	    if ($code == XRules::Present || $code == XRules::ProblemeRetardDepartAnticipe || $code == XRules::EcoleFormationEmploye || $code == XRules::EcoleFormationAlternance || $code == XRules::EcoleFormationIntegration || $code == XRules::Ferie1 || $code == XRules::Ferie2 || $code == XRules::Ferie3) {
		$vendrediEntree	 = new RHDateTime();
		$vendrediEntree->setTime($pl->vendredi_entree);
		$vendrediSortie	 = new RHDateTime();
		$vendrediSortie->setTime($pl->vendredi_sortie);
		if ($refHeure->isBetween($vendrediEntree, $vendrediSortie)) {
		    $vendrediPresence++;
		}
	    }

	    // samedi
	    $code = (int) $pl->samedi_code;
	    if ($code == XRules::CongePaye) {
		$cp++;
	    }
	    if ($code == XRules::Present || $code == XRules::ProblemeRetardDepartAnticipe || $code == XRules::EcoleFormationEmploye || $code == XRules::EcoleFormationAlternance || $code == XRules::EcoleFormationIntegration || $code == XRules::Ferie1 || $code == XRules::Ferie2 || $code == XRules::Ferie3) {
		$samediEntree	 = new RHDateTime();
		$samediEntree->setTime($pl->samedi_entree);
		$samediSortie	 = new RHDateTime();
		$samediSortie->setTime($pl->samedi_sortie);
		if ($refHeure->isBetween($samediEntree, $samediSortie)) {
		    $samediPresence++;
		}
	    }

	    // dimanche
	    $code = (int) $pl->dimanche_code;
	    if ($code == XRules::CongePaye) {
		$cp++;
	    }
	    if ($code == XRules::Present || $code == XRules::ProblemeRetardDepartAnticipe || $code == XRules::EcoleFormationEmploye || $code == XRules::EcoleFormationAlternance || $code == XRules::EcoleFormationIntegration || $code == XRules::Ferie1 || $code == XRules::Ferie2 || $code == XRules::Ferie3) {
		$dimancheEntree	 = new RHDateTime();
		$dimancheEntree->setTime($pl->dimanche_entree);
		$dimancheSortie	 = new RHDateTime();
		$dimancheSortie->setTime($pl->dimanche_sortie);
		if ($refHeure->isBetween($dimancheEntree, $dimancheSortie)) {
		    $dimanchePresence++;
		}
	    }

	    // Les dates de la semaine
	    if (count($daysOfWeek) == 0) {
		$daysOfWeek['lundi']	 = $pl->lundi;
		$daysOfWeek['mardi']	 = $pl->mardi;
		$daysOfWeek['mercredi']	 = $pl->mercredi;
		$daysOfWeek['jeudi']	 = $pl->jeudi;
		$daysOfWeek['vendredi']	 = $pl->vendredi;
		$daysOfWeek['samedi']	 = $pl->samedi;
		$daysOfWeek['dimanche']	 = $pl->dimanche;
	    }
	}
	// transfert
	$tableTransfert = new \RHX\Model\Table\TransfertTable($this->getAdapter());
	foreach ($daysOfWeek as $name => $day) {
	    ////echo "<pre>$name => $day</pre>";
	    $entrants	 = $tableTransfert->getTransfertOfOneDay($day, $siteId, Transfert::Entrant);
	    $prefix		 = $name . 'Presence';
	    $presence	 = $$prefix;
	    foreach ($entrants as $entrant) {
		//var_dump($entrant);
		$in	 = new RHDateTime();
		$in->setTime($entrant->entree);
		$out	 = new RHDateTime();
		$out->setTime($entrant->sortie);
		if ($refHeure->isBetween($in, $out)) {
		    $presence++;
		    ////echo "<pre>Ajout de presence pour $prefix et donne $presence</pre>";
		    $$prefix = $presence;
		}
	    }
	}

	$result = array(
	    'lundi'		 => $lundiPresence,
	    'mardi'		 => $mardiPresence,
	    'mercredi'	 => $mercrediPresence,
	    'jeudi'		 => $jeudiPresence,
	    'vendredi'	 => $vendrediPresence,
	    'samedi'	 => $samediPresence,
	    'dimanche'	 => $dimanchePresence,
	    'cp'		 => $cp,
	    'cpvalue'	 => XRules::CongePaye,
	);

	return new \Zend\View\Model\JsonModel($result);
    }

    /**
     * Remplir Ligne
     * 
     * @return \Zend\View\Model\JsonModel
     */
    public function fillRowAction_old() {
	// POST
	$post = $this->getRequest()
		->getPost();

	// Table
	$planningSemaineTable = $this->getService('Table\PlanningSemaineTable');

	// Planning
	$planning = null;
	try {
	    $planning = $planningSemaineTable->get($post->id);
	}
	catch (\Exception $ex) {
	    $planning = new \RHX\Model\Object\PlanningSemaine($this->getAdapter());
	}

	//var_dump($planning);
	// Calcul des heures
	$total		 = new RHDateTime();
	$total->setTime();
	$retard		 = 0;
	$retardTime	 = new RHDateTime();
	$retardTime->setTime();

	// Total des Pauses
	$pauseTotal = 0;

	// Règles de calcul
	$rules = new XRules($this->getAdapter());

	// Template
	$template = null;
	try {
	    $template = $this->getService('View\PSPlanningView')
		    ->getTemplate($planning->id, $planning->matricule);
	}
	catch (\Exception $ex) {
	    $template = new \RHX\Model\Object\EmployeTemplate($this->getAdapter());
	}
	//var_dump($template);
	// Calcul Heure Travaillé
	// Lundi
	$diff	 = RHDateTime::diffHours($planning->lundi_entree, $planning->lundi_sortie);
	$code	 = (int) $planning->lundi_code;
	// Calcul Total Heure
	if ($rules->isCountable($code)) {
	    $total->addHours($diff, false);
	}
	// Calcul heure de retard
	if ($rules->isLate($code)) {
	    $retard++;
	    // State
	    $state		 = $rules->calculateLateState($code, $planning->lundi_entree, $planning->lundi_sortie, $template->lundi_entree, $template->lundi_sortie);
	    // Variables
	    $retardArray	 = $state['retard'];
	    $departAnticipe	 = $state['departAnticipe'];
	    // Test
	    if ($retardArray['etat']) {
		$retardTime->addHours($retardArray['heure'], false);
	    }
	    if ($departAnticipe['etat']) {
		$retardTime->addHours($departAnticipe['heure'], false);
	    }
	}
	// Pause
	$pauseTotal += (int) $planning->lundi_pause;

	// Mardi
	$diff	 = RHDateTime::diffHours($planning->mardi_entree, $planning->mardi_sortie);
	$code	 = (int) $planning->mardi_code;
	// Calcul total heure
	if ($rules->isCountable($code)) {
	    $total->addHours($diff, false);
	}
	// Calcul heure de retard
	if ($rules->isLate($code)) {
	    $retard++;
	    // State
	    $state		 = $rules->calculateLateState($code, $planning->mardi_entree, $planning->mardi_sortie, $template->mardi_entree, $template->mardi_sortie);
	    // Variables
	    $retardArray	 = $state['retard'];
	    $departAnticipe	 = $state['departAnticipe'];
	    // Test
	    if ($retardArray['etat']) {
		$retardTime->addHours($retardArray['heure'], false);
	    }
	    if ($departAnticipe['etat']) {
		$retardTime->addHours($departAnticipe['heure'], false);
	    }
	}
	// Pause
	$pauseTotal += (int) $planning->mardi_pause;

	// Mercredi
	$diff	 = RHDateTime::diffHours($planning->mercredi_entree, $planning->mercredi_sortie);
	$code	 = (int) $planning->mercredi_code;
	// Calcul total heure
	if ($rules->isCountable($code)) {
	    $total->addHours($diff, false);
	}
	// Calcul heure de retard
	if ($rules->isLate($code)) {
	    $retard++;
	    // State
	    $state		 = $rules->calculateLateState($code, $planning->mercredi_entree, $planning->mercredi_sortie, $template->mercredi_entree, $template->mercredi_sortie);
	    // Variables
	    $retardArray	 = $state['retard'];
	    $departAnticipe	 = $state['departAnticipe'];
	    // Test
	    if ($retardArray['etat']) {
		$retardTime->addHours($retardArray['heure'], false);
	    }
	    if ($departAnticipe['etat']) {
		$retardTime->addHours($departAnticipe['heure'], false);
	    }
	}
	// Pause
	$pauseTotal += (int) $planning->mercredi_pause;

	// Jeudi
	$diff	 = RHDateTime::diffHours($planning->jeudi_entree, $planning->jeudi_sortie);
	$code	 = (int) $planning->jeudi_code;
	// Calcul total heure
	if ($rules->isCountable($code)) {
	    $total->addHours($diff, false);
	}
	// Calcul heure de retard
	if ($rules->isLate($code)) {
	    $retard++;
	    // State
	    $state		 = $rules->calculateLateState($code, $planning->jeudi_entree, $planning->jeudi_sortie, $template->jeudi_entree, $template->jeudi_sortie);
	    // Variables
	    $retardArray	 = $state['retard'];
	    $departAnticipe	 = $state['departAnticipe'];
	    // Test
	    if ($retardArray['etat']) {
		$retardTime->addHours($retardArray['heure'], false);
	    }
	    if ($departAnticipe['etat']) {
		$retardTime->addHours($departAnticipe['heure'], false);
	    }
	}
	// Pause
	$pauseTotal += (int) $planning->jeudi_pause;

	// Vendredi
	$diff	 = RHDateTime::diffHours($planning->vendredi_entree, $planning->vendredi_sortie);
	$code	 = (int) $planning->vendredi_code;
	// Calcul total d'heure
	if ($rules->isCountable($code)) {
	    $total->addHours($diff, false);
	}
	// Calcul heure de retard
	if ($rules->isLate($code)) {
	    $retard++;
	    // State
	    $state		 = $rules->calculateLateState($code, $planning->vendredi_entree, $planning->vendredi_sortie, $template->vendredi_entree, $template->vendredi_sortie);
	    // Variables
	    $retardArray	 = $state['retard'];
	    $departAnticipe	 = $state['departAnticipe'];
	    // Test
	    if ($retardArray['etat']) {
		$retardTime->addHours($retardArray['heure'], false);
	    }
	    if ($departAnticipe['etat']) {
		$retardTime->addHours($departAnticipe['heure'], false);
	    }
	}
	// Pause
	$pauseTotal += (int) $planning->vendredi_pause;

	// Samedi
	$diff	 = RHDateTime::diffHours($planning->samedi_entree, $planning->samedi_sortie);
	$code	 = (int) $planning->samedi_code;
	// Calcul total heure
	if ($rules->isCountable($code)) {
	    $total->addHours($diff, false);
	}
	// Heure de retard
	if ($rules->isLate($code)) {
	    $retard++;
	    // State
	    $state		 = $rules->calculateLateState($code, $planning->samedi_entree, $planning->samedi_sortie, $template->samedi_entree, $template->samedi_sortie);
	    // Variables
	    $retardArray	 = $state['retard'];
	    $departAnticipe	 = $state['departAnticipe'];
	    // Test
	    if ($retardArray['etat']) {
		$retardTime->addHours($retardArray['heure'], false);
	    }
	    if ($departAnticipe['etat']) {
		$retardTime->addHours($departAnticipe['heure'], false);
	    }
	}
	// Pause
	$pauseTotal += (int) $planning->samedi_pause;

	// Dimanche
	$diff	 = RHDateTime::diffHours($planning->dimanche_entree, $planning->dimanche_sortie);
	$code	 = (int) $planning->dimanche_code;
	// Calcul total heure
	if ($rules->isCountable($code)) {
	    $total->addHours($diff, false);
	}
	// Calcul heure de retard
	if ($rules->isLate($code)) {
	    $retard++;
	    // State
	    $state		 = $rules->calculateLateState($code, $planning->dimanche_entree, $planning->dimanche_sortie, $template->dimanche_entree, $template->dimanche_sortie);
	    // Variables
	    $retardArray	 = $state['retard'];
	    $departAnticipe	 = $state['departAnticipe'];
	    // Test
	    if ($retardArray['etat']) {
		$retardTime->addHours($retardArray['heure'], false);
	    }
	    if ($departAnticipe['etat']) {
		$retardTime->addHours($departAnticipe['heure'], false);
	    }
	}
	// Pause
	$pauseTotal += (int) $planning->dimanche_pause;

	// Retard
	$planning->retard	 = $retard;
	$planning->retard_heure	 = $retardTime->totalHours();

	// Traitement des pauses
	$totalPause			 = $pauseTotal * 0.5;
	$strPause			 = number_format($totalPause, 2, ',', '');
	$heurePause			 = RHDateTime::toTime($strPause);
	$heureTravailleMoinsHeurePause	 = RHDateTime::diffHours($total->totalHours(), $heurePause, false);

	// Debug
//	//echo 'Nombre de pause';
//	var_dump($pauseTotal);
//	//echo 'Pause en Float';
//	var_dump($totalPause);
//	//echo 'pause en Float String';
//	var_dump($strPause);
//	//echo 'Pause en Heure';
//	var_dump($heurePause);
//	//echo 'Heure travaillé - pause';
//	var_dump($heureTravailleMoinsHeurePause);
//	//echo 'Heure travaillé';
//	var_dump($total->totalHours());
	// Heures Travaillé
	$planning->heure_travaille = $heureTravailleMoinsHeurePause;

	// Employé
	$employe = null;
	try {
	    $employe = $planning->getEmploye();
	}
	catch (\Exception $ex) {
	    $employe = new \RHX\Model\Object\Employe($this->getAdapter());
	}
	// Avenant de l'employé
	$avenant = null;
	try {
	    $avenant = $employe->getAvenant();
	}
	catch (\Exception $ex) {
	    $avenant = new \RHX\Model\Object\Avenant($this->getAdapter());
	}
	$hebdo_heure		 = (int) $avenant->hebdo;
	$hebdo_minute		 = 0;
	// Calcul des heures non planiffié
	$diff_heure		 = 0;
	$diff_minute		 = 0;
	$travaille		 = explode(':', $planning->heure_travaille);
	$travaille_heure	 = (int) $travaille[0];
	$travaille_minute	 = (int) $travaille[1];
	if ($travaille_minute >= $hebdo_minute) {
	    // Calcul normal
	    $diff_minute	 = $travaille_minute - $hebdo_minute;
	    $diff_heure	 = $travaille_heure - $hebdo_heure;
	}
	else {
	    // on enlève une heure
	    $travaille_heure--;
	    $travaille_minute += 60;
	    $diff_minute	 = $travaille_minute - $hebdo_minute;
	    $diff_heure	 = $travaille_heure - $travaille_heure;
	}
	$diff_heure	 = ((int) $diff_heure < 10 && (int) $diff_heure >= 0) ? '0' . $diff_heure : $diff_heure;
	$diff_minute	 = ((int) $diff_minute < 10) ? '0' . $diff_minute : $diff_minute;
	$diff		 = "$diff_heure:$diff_minute";

	// Heure non planninfié
	$planning->heure_non_planifie = $diff;

	// Sauvegarde dans la base de données
	//$planningSemaineTable->save($planning);
	// Resultat
	$result = array(
	    'heurePrevue'		 => $planning->heure_travaille,
	    'heureNonPlanifie'	 => $planning->heure_non_planifie,
	    'retard'		 => $planning->retard,
	    'retardHeure'		 => $planning->retard_heure,
	);

	return new \Zend\View\Model\JsonModel($result);
    }

    public function fillRowAction() {
	// POST
	$post = $this->getRequest()
		->getPost();

	// Planning Semaine Table
	$planningTable = new \RHX\Model\Table\PlanningSemaineTable($this->getAdapter());

	// Planning
	$planning = null;
	try {
	    $planning = $planningTable->get($post->id);
	}
	catch (\Exception $ex) {
	    $planning = new \RHX\Model\Object\PlanningSemaine($this->getAdapter());
	}

	// Template de création du planning
	$template = $planning->getTemplate();

	// Règles
	$rule = new XRules($this->getAdapter());

	// Lundi
	$dataLundi	 = $rule->Calcul($planning->lundi_code, $planning->matricule, $planning->lundi_entree, $planning->lundi_sortie, $planning->lundi_pause, $planning->lundi_repas, $planning->coef, $template->lundi_entree, $template->lundi_sortie);
	// Mardi
	$dataMardi	 = $rule->Calcul($planning->mardi_code, $planning->matricule, $planning->mardi_entree, $planning->mardi_sortie, $planning->mardi_pause, $planning->mardi_repas, $planning->coef, $template->mardi_entree, $template->mardi_sortie);
	// Mercredi
	$dataMercredi	 = $rule->Calcul($planning->mercredi_code, $planning->matricule, $planning->mercredi_entree, $planning->mercredi_sortie, $planning->mercredi_pause, $planning->mercredi_repas, $planning->coef, $template->mercredi_entree, $template->mercredi_sortie);
	// Jeudi
	$dataJeudi	 = $rule->Calcul($planning->jeudi_code, $planning->matricule, $planning->jeudi_entree, $planning->jeudi_sortie, $planning->jeudi_pause, $planning->jeudi_repas, $planning->coef, $template->jeudi_entree, $template->jeudi_sortie);
	// Vendredi
	$dataVendredi	 = $rule->Calcul($planning->vendredi_code, $planning->matricule, $planning->vendredi_entree, $planning->vendredi_sortie, $planning->vendredi_pause, $planning->vendredi_repas, $planning->coef, $template->vendredi_entree, $template->vendredi_sortie);
	// Samedi
	$dataSamedi	 = $rule->Calcul($planning->samedi_code, $planning->matricule, $planning->samedi_entree, $planning->samedi_sortie, $planning->samedi_pause, $planning->samedi_repas, $planning->coef, $template->samedi_entree, $template->samedi_sortie);
	// Dimanche
	$dataDimanche	 = $rule->Calcul($planning->dimanche_code, $planning->matricule, $planning->dimanche_entree, $planning->dimanche_sortie, $planning->dimanche_pause, $planning->dimanche_repas, $planning->coef, $template->dimanche_entree, $template->dimanche_sortie);

	// Total des heures de Travail
	$heureTravail = new RHDateTime();
	$heureTravail->setTime();
	$heureTravail->addHours($dataLundi->tempsDiff, false);
	$heureTravail->addHours($dataMardi->tempsDiff, false);
	$heureTravail->addHours($dataMercredi->tempsDiff, false);
	$heureTravail->addHours($dataJeudi->tempsDiff, false);
	$heureTravail->addHours($dataVendredi->tempsDiff, false);
	$heureTravail->addHours($dataSamedi->tempsDiff, false);
	$heureTravail->addHours($dataDimanche->tempsDiff, false);

	// Total des Retards et Depart anticipe
	$nbPRDA		 = 0;
	$heurePRDA	 = new RHDateTime();
	$heurePRDA->setTime();


	// Lundi
	if ($dataLundi->retard) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataLundi->tempsRetard, false);
	}
	if ($dataLundi->anticipe) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataLundi->tempsAnticipe, false);
	}

	// Mardi
	if ($dataMardi->retard) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataMardi->tempsRetard, false);
	}
	if ($dataMardi->anticipe) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataMardi->tempsAnticipe, false);
	}


	// Mercredi
	if ($dataMercredi->retard) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataMercredi->tempsRetard, false);
	}
	if ($dataMercredi->anticipe) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataMercredi->tempsAnticipe, false);
	}


	// Jeudi
	if ($dataJeudi->retard) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataJeudi->tempsRetard, false);
	}
	if ($dataJeudi->anticipe) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataJeudi->tempsAnticipe, false);
	}


	// Vendredi
	if ($dataVendredi->retard) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataVendredi->tempsRetard, false);
	}
	if ($dataVendredi->anticipe) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataVendredi->tempsAnticipe, false);
	}


	// Samedi
	if ($dataSamedi->retard) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataSamedi->tempsRetard, false);
	}
	if ($dataSamedi->anticipe) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataSamedi->tempsAnticipe, false);
	}


	// Dimanche
	if ($dataDimanche->retard) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataDimanche->tempsRetard, false);
	}
	if ($dataDimanche->anticipe) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataDimanche->tempsAnticipe, false);
	}


	// Employé
	$employe = $planning->getEmploye();

	// Heure Travaillé
	$heurePrevue = RHDateTime::toTime(number_format($planning->heure_travaille, 2, ',', ' '));

	// Résultat
	$result = array(
	    'heurePrevue'		 => $heurePrevue,
	    'heureNonPlanifie'	 => $employe->getHeureNonPlanifiePeriode($planning->lundi),
	    'retard'		 => $nbPRDA,
	    'retardHeure'		 => $heurePRDA->totalHours(),
	);

	return new \Zend\View\Model\JsonModel($result);
    }

    /**
     * Remplissage de colonne
     * 
     * @return \Zend\View\Model\JsonModel
     */
    public function fillColAction() {
	try {// POST
	    $post		 = $this->getRequest()
		    ->getPost();
	    // Table planning
	    $tablePlanning	 = new \RHX\Model\Table\PlanningSemaineTable($this->getAdapter());
	    // Table Employé
	    $tableEmploye	 = new \RHX\Model\Table\EmployeTable(($this->getAdapter()));
	    // Liste des employés du site
	    $employeList	 = $tableEmploye->getEmployesBySite($post->site);
	    $employes	 = array();
	    $emp		 = array();
	    // Parcours de la liste des employés
	    foreach ($employeList as $e) {
		$employes[]		 = $e->matricule;
		$emp[$e->matricule]	 = $e;
	    }
	    $erreurs	 = array();
	    // Planning semaine correspondant
	    $plannings	 = $tablePlanning->getPlanningByEmploye($post->lundi, $employes);
	    if ($plannings->count() < 1) {
		$erreurs[] = "Les plannings est vide";
	    }
	    // Parcours des plannings
	    $heureTravaille	 = array('lundi' => new RHDateTime(), 'mardi' => new RHDateTime(), 'mercredi' => new RHDateTime(), 'jeudi' => new RHDateTime(), 'vendredi' => new RHDateTime(), 'samedi' => new RHDateTime(), 'dimanche' => new RHDateTime(),);
	    $travaillees	 = array('lundi' => new RHDateTime(), 'mardi' => new RHDateTime(), 'mercredi' => new RHDateTime(), 'jeudi' => new RHDateTime(), 'vendredi' => new RHDateTime(), 'samedi' => new RHDateTime(), 'dimanche' => new RHDateTime(),);
	    $total		 = array('lundi' => new RHDateTime(), 'mardi' => new RHDateTime(), 'mercredi' => new RHDateTime(), 'jeudi' => new RHDateTime(), 'vendredi' => new RHDateTime(), 'samedi' => new RHDateTime(), 'dimanche' => new RHDateTime(),);
	    // Mise à zéro des heures
	    foreach ($heureTravaille as $heure) {
		$heure->setTime();
	    }
	    // Variable de retour
	    $MOSite		 = array('lundi' => 0.0, 'mardi' => 0.0, 'mercredi' => 0.0, 'jeudi' => 0.0, 'vendredi' => 0.0, 'samedi' => 0.0, 'dimanche' => 0.0,);
	    $MOEntrant	 = array('lundi' => 0.0, 'mardi' => 0.0, 'mercredi' => 0.0, 'jeudi' => 0.0, 'vendredi' => 0.0, 'samedi' => 0.0, 'dimanche' => 0.0,);
	    $MOSortant	 = array('lundi' => 0.0, 'mardi' => 0.0, 'mercredi' => 0.0, 'jeudi' => 0.0, 'vendredi' => 0.0, 'samedi' => 0.0, 'dimanche' => 0.0,);
	    $prefixes	 = array('lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche',);
	    $productivite	 = array('lundi' => 0.0, 'mardi' => 0.0, 'mercredi' => 0.0, 'jeudi' => 0.0, 'vendredi' => 0.0, 'samedi' => 0.0, 'dimanche' => 0.0,);
            $previsionCa	 = array('lundi' => 0.0, 'mardi' => 0.0, 'mercredi' => 0.0, 'jeudi' => 0.0, 'vendredi' => 0.0, 'samedi' => 0.0, 'dimanche' => 0.0,);
	    $MOTotal	 = array('lundi' => 0.0, 'mardi' => 0.0, 'mercredi' => 0.0, 'jeudi' => 0.0, 'vendredi' => 0.0, 'samedi' => 0.0, 'dimanche' => 0.0,);
	    $planningArray	 = array();
	    $transactions	 = array();
	    $daysOfWeek	 = array();
	    $siteId		 = (int) $post->site;
	    // Calculator
	    $calculator	 = new \RHX\Model\Object\XCalculator($this->getAdapter());
	    $tableTransfert	 = new \RHX\Model\Table\TransfertTable(($this->getAdapter()));
	    // Parcours des plannings
	    foreach ($plannings as $planning) {
		$template	 = $planning->getTemplate();
		$dataLundi	 = $calculator->calculateOneDay($planning, $template, 'lundi');
		$dataMardi	 = $calculator->calculateOneDay($planning, $template, 'mardi');
		$dataMercredi	 = $calculator->calculateOneDay($planning, $template, 'mercredi');
		$dataJeudi	 = $calculator->calculateOneDay($planning, $template, 'jeudi');
		$dataVendredi	 = $calculator->calculateOneDay($planning, $template, 'vendredi');
		$dataSamedi	 = $calculator->calculateOneDay($planning, $template, 'samedi');
		$dataDimanche	 = $calculator->calculateOneDay($planning, $template, 'dimanche');
		// employe
		$employe	 = $planning->getEmploye();
		$dataCP		 = $employe->getDataCP();
		$coef		 = $dataCP['coef'];
		$taux		 = $dataCP['taux'];
		// Heures travaillés sur site
		foreach ($prefixes as $prefix) {
		    $dataName		 = 'data' . ucfirst($prefix);
		    $data			 = $$dataName;
		    $heureTravaille[$prefix]->addHours($data->tempsDiff, false);
		    $price			 = $data->tempsDiff * $coef * $taux;
		    $MOSite[$prefix] += $price;
		    $daysOfWeek[$prefix]	 = $planning->$prefix;
		    // heures totales
		    $t			 = $calculator->calculHeureTotales($planning, $data, $prefix);
		    $total[$prefix]->addHours($t->totalHours(), false);
		    // heures travaille
		    $ht			 = $calculator->calculHeureTravaillees($planning, $data, $prefix);
		    $travaillees[$prefix]->addHours($ht->totalHours(), false);
		    // Main d'oeuvre
		    $MOTotal[$prefix] += $calculator->calculMOTotal($planning, $data, $prefix);
		}
		$planningArray[] = $planning;
	    }
	    // Transferts
	    $pauseTime = '00:30';
	    foreach ($daysOfWeek as $day) {
		$entrants	 = $tableTransfert->getTransfertOfOneDay($day, $siteId, Transfert::Entrant);
		$sortants	 = $tableTransfert->getTransfertOfOneDay($day, $siteId, Transfert::Sortant);
		$dayName	 = RHDateTime::dayName($day);
		// MO TE
		foreach ($entrants as $entrant) {
		    $diff = RHDateTime::diffHours($entrant->sortie, $entrant->entree);
		    if ((int) $entrant->pause == 1) {
			$diff = RHDateTime::diffHours($diff, $pauseTime);
		    }
		    $employe = $entrant->getEmploye();
		    $cp	 = $employe->getDataCP();
		    $price	 = RHDateTime::toFloat($diff) * $cp['coef'] * $cp['taux'];
		    $MOEntrant[$dayName] += $price;
		    $MOSite[$dayName] += $MOEntrant[$dayName];
		    $heureTravaille[$dayName]->addHours($diff, false);
		    // heure total
		    $total[$dayName]->addHours($diff, false);
		    // heure travailles
		    $travaillees[$dayName]->addHours($diff, false);
		    // mo total
		    $MOTotal[$dayName] += $price;
		}
		// MO TS
		foreach ($sortants as $sortant) {
		    $diff = RHDateTime::diffHours($sortant->sortie, $sortant->entree);
		    if ((int) $sortant->pause == 1) {
			$diff = RHDateTime::diffHours($diff, $pauseTime);
		    }
		    $employe = $sortant->getEmploye();
		    $cp	 = $employe->getDataCP();
		    $MOSortant[$dayName] += RHDateTime::toFloat($diff) * $cp['coef'] * $cp['taux'];
		}
	    }

	    // Nombre de transaction et caclcul de productivité
	    foreach ($daysOfWeek as $day => $date) {
		$nbTransaction		 = $this->getNbTransaction($siteId, $date);
		$transactions[$day]	 = $nbTransaction;
		$work			 = RHDateTime::toFloat($travaillees[$day]->totalHours());
		$productivite[$day]	 = ($nbTransaction == 0 || $work == 0) ? 0 : $nbTransaction / $work;
	    }
            
             // Nombre de transaction et caclcul de productivité
	    foreach ($daysOfWeek as $day => $date) {
		$prev_ca		 = $this->getPrevisionCa($siteId, $date);		
		$previsionCa[$day]	 = $prev_ca;
	    }

	    // Formatage des résultats
	    $heures = array();
	    foreach ($heureTravaille as $prefix => $heure) {
		$MOSite[$prefix]	 = number_format($MOSite[$prefix], 2, ',', ' ');
		$MOEntrant[$prefix]	 = number_format($MOEntrant[$prefix], 2, ',', ' ');
		$MOSortant[$prefix]	 = number_format($MOSortant[$prefix], 2, ',', ' ');
		$heures[$prefix]	 = number_format(RHDateTime::toFloat($heure->totalHours()), 2, ',', ' ');
		$travaillees[$prefix]	 = number_format(RHDateTime::toFloat($travaillees[$prefix]->totalHours()), 2, ',', ' ');
		$total[$prefix]		 = number_format(RHDateTime::toFloat($total[$prefix]->totalHours()), 2, ',', ' ');
		$MOTotal[$prefix]	 = number_format($MOTotal[$prefix], 2, ',', ' ');
		$productivite[$prefix]	 = number_format($productivite[$prefix], 2, ',', ' ');
                $previsionCa[$prefix]    = number_format($previsionCa[$prefix], 2, ',', ' ');
	    }

	    $resultat = array(
		'heures'	 => $heures,
		'site'		 => $MOSite,
		'entrant'	 => $MOEntrant,
		'sortant'	 => $MOSortant,
		'productivite'	 => $productivite,
                'prevision_ca'	 => $previsionCa,
		'travaille'	 => $travaillees,
		'total'		 => $total,
		'mo'		 => $MOTotal,
	    );

	    return new \Zend\View\Model\JsonModel($resultat);
	}
	catch (\Exception $ex) {
	    //var_dump($ex);
	    throw $ex;
	    return new \Zend\View\Model\JsonModel(array(
		'exception' => $ex,
	    ));
	}
    }

    /**
     * Remplissage des colonnes
     *
     * @return \Zend\View\Model\JsonModel
     */
    public function fillColAction_old() {
	// Post
	$post = $this->getRequest()
		->getPost();

	// Table
	$employeTable	 = $this->getService('Table\EmployeTable');
	$planningTable	 = $this->getService('Table\PlanningSemaineTable');

	// Liste des employés du Site
	$employeList	 = $employeTable->getEmployesBySite($post->site);
	// Parcours des employés
	$employes	 = array();
	$emp		 = array();
	foreach ($employeList as $e) {
	    $employes[]		 = $e->matricule;
	    $emp[$e->matricule]	 = $e;
	}

	// Planning Semaine correspondant
	$plannings = $planningTable->getPlanningByEmploye($post->lundi, $employes);

	// Parcours des plannings
	$heureTravaille = array();

	$heureTravaille['lundi']	 = new RHDateTime();
	$heureTravaille['lundi']->setTime();
	$heureTravaille['mardi']	 = new RHDateTime();
	$heureTravaille['mardi']->setTime();
	$heureTravaille['mercredi']	 = new RHDateTime();
	$heureTravaille['mercredi']->setTime();
	$heureTravaille['jeudi']	 = new RHDateTime();
	$heureTravaille['jeudi']->setTime();
	$heureTravaille['vendredi']	 = new RHDateTime();
	$heureTravaille['vendredi']->setTime();
	$heureTravaille['samedi']	 = new RHDateTime();
	$heureTravaille['samedi']->setTime();
	$heureTravaille['dimanche']	 = new RHDateTime();
	$heureTravaille['dimanche']->setTime();

//	//echo "Initialisation : " . $heureTravaille->totalHours() . "\n";
	$MOSite			 = array(
	    'lundi'		 => 0.0, 'mardi'		 => 0.0, 'mercredi'	 => 0.0, 'jeudi'		 => 0.0, 'vendredi'	 => 0.0, 'samedi'	 => 0.0, 'dimanche'	 => 0.0,
	);
	$MOEntrant		 = array(
	    'lundi'		 => 0.0, 'mardi'		 => 0.0, 'mercredi'	 => 0.0, 'jeudi'		 => 0.0, 'vendredi'	 => 0.0, 'samedi'	 => 0.0, 'dimanche'	 => 0.0,
	);
	;
	$MOSortant		 = array(
	    'lundi'		 => 0.0, 'mardi'		 => 0.0, 'mercredi'	 => 0.0, 'jeudi'		 => 0.0, 'vendredi'	 => 0.0, 'samedi'	 => 0.0, 'dimanche'	 => 0.0,
	);
	$pause			 = '00:30';
	$transfertEntrant	 = 0;
	$transfertSortant	 = 0;
	foreach ($plannings as $pl) {
	    // Employe
	    $e	 = $emp[$pl->matricule];
	    $coef	 = $e->getCoefficient();
	    $avenant = $e->getAvenant();
	    $taux	 = floatval($avenant->taux);

	    // lundi
	    // Test du code
	    $diff = RHDateTime::diffHours($pl->lundi_entree, $pl->lundi_sortie);
	    if ((int) $pl->lundi_pause == 1) {
		$diff = RHDateTime::diffHours($diff, $pause, false);
	    }
	    switch ((int) $pl->lundi_code) {
		case XRules::Present:
		case XRules::ProblemeRetardDepartAnticipe:
		    // Heure Travaillé Sur site
		    $heureTravaille['lundi']->addHours($diff, false);
		    // Main d'oeuvre sur Site
		    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
		    $MOSite['lundi'] += $mo;
		    break;
		case XRules::TransfertEntrant:
		    // Heure Travaillé Sur site
		    $heureTravaille['lundi']->addHours($diff, false);
		    // Main d'oeuvre sur Site
		    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
		    $MOSite['lundi'] += $mo;
		    // Main d'oeuvre sur Transfert Entrant
		    $MOEntrant['lundi'] += $mo;
		    $transfertEntrant++;
		    break;
		case XRules::TransfertSortant:
		    // Main d'oeuvre sur Transfert Sortant
		    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
		    $MOSortant['lundi'] += $mo;
		    $transfertSortant++;
		    break;
	    }

	    // mardi
	    // Test du code
	    $diff = RHDateTime::diffHours($pl->mardi_entree, $pl->mardi_sortie);
	    if ((int) $pl->mardi_pause == 1) {
		$diff = RHDateTime::diffHours($diff, $pause, false);
	    }
	    switch ((int) $pl->mardi_code) {
		case XRules::Present:
		case XRules::ProblemeRetardDepartAnticipe:
		    // Heure Travaillé Sur site
		    $heureTravaille['mardi']->addHours($diff, false);
		    // Main d'oeuvre sur Site
		    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
		    $MOSite['mardi'] += $mo;
		    break;
		case XRules::TransfertEntrant:
		    // Heure Travaillé Sur site
		    $heureTravaille['mardi']->addHours($diff, false);
		    // Main d'oeuvre sur Site
		    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
		    $MOSite['mardi'] += $mo;
		    // Main d'oeuvre sur Transfert Entrant
		    $MOEntrant['mardi'] += $mo;
		    $transfertEntrant++;
		    break;
		case XRules::TransfertSortant:
		    // Main d'oeuvre sur Transfert Sortant
		    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
		    $MOSortant['mardi'] += $mo;
		    $transfertSortant++;
		    break;
	    }

	    // mercredi
	    // Test du code
	    $diff = RHDateTime::diffHours($pl->mercredi_entree, $pl->mercredi_sortie);
	    if ((int) $pl->mercredi_pause == 1) {
		$diff = RHDateTime::diffHours($diff, $pause, false);
	    }
	    switch ((int) $pl->mercredi_code) {
		case XRules::Present:
		case XRules::ProblemeRetardDepartAnticipe:
		    // Heure Travaillé Sur site
		    $heureTravaille['mercredi']->addHours($diff, false);
		    // Main d'oeuvre sur Site
		    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
		    $MOSite['mercredi'] += $mo;
		    break;
		case XRules::TransfertEntrant:
		    // Heure Travaillé Sur site
		    $heureTravaille['mercredi']->addHours($diff, false);
		    // Main d'oeuvre sur Site
		    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
		    $MOSite['mercredi'] += $mo;
		    // Main d'oeuvre sur Transfert Entrant
		    $MOEntrant['mercredi'] += $mo;
		    $transfertEntrant++;
		    break;
		case XRules::TransfertSortant:
		    // Main d'oeuvre sur Transfert Sortant
		    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
		    $MOSortant['mercredi'] += $mo;
		    $transfertSortant++;
		    break;
	    }

	    // jeudi
	    // Test du code
	    $diff = RHDateTime::diffHours($pl->jeudi_entree, $pl->jeudi_sortie);
	    if ((int) $pl->jeudi_pause == 1) {
		$diff = RHDateTime::diffHours($diff, $pause, false);
	    }
	    switch ((int) $pl->jeudi_code) {
		case XRules::Present:
		case XRules::ProblemeRetardDepartAnticipe:
		    // Heure Travaillé Sur site
		    $heureTravaille['jeudi']->addHours($diff, false);
		    // Main d'oeuvre sur Site
		    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
		    $MOSite['jeudi'] += $mo;
		    break;
		case XRules::TransfertEntrant:
		    // Heure Travaillé Sur site
		    $heureTravaille['jeudi']->addHours($diff, false);
		    // Main d'oeuvre sur Site
		    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
		    $MOSite['jeudi'] += $mo;
		    // Main d'oeuvre sur Transfert Entrant
		    $MOEntrant['jeudi'] += $mo;
		    $transfertEntrant++;
		    break;
		case XRules::TransfertSortant:
		    // Main d'oeuvre sur Transfert Sortant
		    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
		    $MOSortant['jeudi'] += $mo;
		    $transfertSortant++;
		    break;
	    }

	    // vendredi
	    // Test du code
	    $diff = RHDateTime::diffHours($pl->vendredi_entree, $pl->vendredi_sortie);
	    if ((int) $pl->vendredi_pause == 1) {
		$diff = RHDateTime::diffHours($diff, $pause, false);
	    }
	    switch ((int) $pl->vendredi_code) {
		case XRules::Present:
		case XRules::ProblemeRetardDepartAnticipe:
		    // Heure Travaillé Sur site
		    $heureTravaille['vendredi']->addHours($diff, false);
		    // Main d'oeuvre sur Site
		    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
		    $MOSite['vendredi'] += $mo;
		    break;
		case XRules::TransfertEntrant:
		    // Heure Travaillé Sur site
		    $heureTravaille['vendredi']->addHours($diff, false);
		    // Main d'oeuvre sur Site
		    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
		    $MOSite['vendredi'] += $mo;
		    // Main d'oeuvre sur Transfert Entrant
		    $MOEntrant['vendredi'] += $mo;
		    $transfertEntrant++;
		    break;
		case XRules::TransfertSortant:
		    // Main d'oeuvre sur Transfert Sortant
		    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
		    $MOSortant['vendredi'] += $mo;
		    $transfertSortant++;
		    break;
	    }

	    // samedi
	    // Test du code
	    $diff = RHDateTime::diffHours($pl->samedi_entree, $pl->samedi_sortie);
	    if ((int) $pl->samedi_pause == 1) {
		$diff = RHDateTime::diffHours($diff, $pause, false);
	    }
	    switch ((int) $pl->samedi_code) {
		case XRules::Present:
		case XRules::ProblemeRetardDepartAnticipe:
		    // Heure Travaillé Sur site
		    $heureTravaille['samedi']->addHours($diff, false);
		    // Main d'oeuvre sur Site
		    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
		    $MOSite['samedi'] += $mo;
		    break;
		case XRules::TransfertEntrant:
		    // Heure Travaillé Sur site
		    $heureTravaille['samedi']->addHours($diff, false);
		    // Main d'oeuvre sur Site
		    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
		    $MOSite['samedi'] += $mo;
		    // Main d'oeuvre sur Transfert Entrant
		    $MOEntrant['samedi'] += $mo;
		    $transfertEntrant++;
		    break;
		case XRules::TransfertSortant:
		    // Main d'oeuvre sur Transfert Sortant
		    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
		    $MOSortant['samedi'] += $mo;
		    $transfertSortant++;
		    break;
	    }

	    // dimanche
	    // Test du code
	    $diff = RHDateTime::diffHours($pl->dimanche_entree, $pl->dimanche_sortie);
	    if ((int) $pl->dimanche_pause == 1) {
		$diff = RHDateTime::diffHours($diff, $pause, false);
	    }
	    switch ((int) $pl->dimanche_code) {
		case XRules::Present:
		case XRules::ProblemeRetardDepartAnticipe:
		    // Heure Travaillé Sur site
		    $heureTravaille['dimanche']->addHours($diff, false);
		    // Main d'oeuvre sur Site
		    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
		    $MOSite['dimanche'] += $mo;
		    break;
		case XRules::TransfertEntrant:
		    // Heure Travaillé Sur site
		    $heureTravaille['dimanche']->addHours($diff, false);
		    // Main d'oeuvre sur Site
		    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
		    $MOSite['dimanche'] += $mo;
		    // Main d'oeuvre sur Transfert Entrant
		    $MOEntrant['dimanche'] += $mo;
		    $transfertEntrant++;
		    break;
		case XRules::TransfertSortant:
		    // Main d'oeuvre sur Transfert Sortant
		    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
		    $MOSortant['dimanche'] += $mo;
		    $transfertSortant++;
		    break;
	    }
	}

	// Transferts Entrant sur le site en cours
	$transfertTable		 = $this->getService("Table\TransfertTable");
	$transfertEntrants	 = $transfertTable->getTransfert($post->lundi, $post->site, 1);
	foreach ($transfertEntrants as $transfert) {
	    $diff	 = RHDateTime::diffHours($transfert->sortie, $transfert->entree);
	    $employe = $transfert->getEmploye();
	    $coef	 = $employe->getCoefficient();
	    $avenant = $employe->getAvenant();
	    $taux	 = floatval($avenant->taux);
	    $mo	 = RHDateTime::toFloat($diff) * $taux * $coef;
	    $transfertEntrant++;
	    $nomJour = RHDateTime::dayName($transfert->journee);
	    $MOEntrant[$nomJour] += $mo;
	}

	// Résultats
	$totalHours		 = array();
	$totalHours['lundi']	 = number_format(RHDateTime::toFloat($heureTravaille['lundi']->totalHours()), 2, ',', ' ');
	$totalHours['mardi']	 = number_format(RHDateTime::toFloat($heureTravaille['mardi']->totalHours()), 2, ',', ' ');
	$totalHours['mercredi']	 = number_format(RHDateTime::toFloat($heureTravaille['mercredi']->totalHours()), 2, ',', ' ');
	$totalHours['jeudi']	 = number_format(RHDateTime::toFloat($heureTravaille['jeudi']->totalHours()), 2, ',', ' ');
	$totalHours['vendredi']	 = number_format(RHDateTime::toFloat($heureTravaille['vendredi']->totalHours()), 2, ',', ' ');
	$totalHours['samedi']	 = number_format(RHDateTime::toFloat($heureTravaille['samedi']->totalHours()), 2, ',', ' ');
	$totalHours['dimanche']	 = number_format(RHDateTime::toFloat($heureTravaille['dimanche']->totalHours()), 2, ',', ' ');

	// Parcours des MO entrant et sortant
	$MOSite['lundi']	 = number_format($MOSite['lundi'], 2, ',', ' ');
	$MOEntrant['lundi']	 = number_format($MOEntrant['lundi'], 2, ',', ' ');
	$MOSortant['lundi']	 = number_format($MOSortant['lundi'], 2, ',', ' ');
	$MOSite['mardi']	 = number_format($MOSite['mardi'], 2, ',', ' ');
	$MOEntrant['mardi']	 = number_format($MOEntrant['mardi'], 2, ',', ' ');
	$MOSortant['mardi']	 = number_format($MOSortant['mardi'], 2, ',', ' ');
	$MOSite['mercredi']	 = number_format($MOSite['mercredi'], 2, ',', ' ');
	$MOEntrant['mercredi']	 = number_format($MOEntrant['mercredi'], 2, ',', ' ');
	$MOSortant['mercredi']	 = number_format($MOSortant['mercredi'], 2, ',', ' ');
	$MOSite['jeudi']	 = number_format($MOSite['jeudi'], 2, ',', ' ');
	$MOEntrant['jeudi']	 = number_format($MOEntrant['jeudi'], 2, ',', ' ');
	$MOSortant['jeudi']	 = number_format($MOSortant['jeudi'], 2, ',', ' ');
	$MOSite['vendredi']	 = number_format($MOSite['vendredi'], 2, ',', ' ');
	$MOEntrant['vendredi']	 = number_format($MOEntrant['vendredi'], 2, ',', ' ');
	$MOSortant['vendredi']	 = number_format($MOSortant['vendredi'], 2, ',', ' ');
	$MOSite['samedi']	 = number_format($MOSite['samedi'], 2, ',', ' ');
	$MOEntrant['samedi']	 = number_format($MOEntrant['samedi'], 2, ',', ' ');
	$MOSortant['samedi']	 = number_format($MOSortant['samedi'], 2, ',', ' ');
	$MOSite['dimanche']	 = number_format($MOSite['dimanche'], 2, ',', ' ');
	$MOEntrant['dimanche']	 = number_format($MOEntrant['dimanche'], 2, ',', ' ');
	$MOSortant['dimanche']	 = number_format($MOSortant['dimanche'], 2, ',', ' ');

	$resultat = array(
	    'heures'		 => $totalHours,
	    'site'			 => $MOSite,
	    'entrant'		 => $MOEntrant,
	    'sortant'		 => $MOSortant,
	    'transfertEntrant'	 => $transfertEntrant,
	    'transfertSortant'	 => $transfertSortant,
	);

	return new \Zend\View\Model\JsonModel($resultat);
    }

    public function getOccurenceAction() {
	// Données en post
	$post = $this->getRequest()
		->getPost();

	// Table PlanningSemaine
	$planningTable = $this->getService('Table/PlanningSemaineTable');

	// Occurence du code
	$nb = $planningTable->getOccurencePeriode($post->code, $post->matricule, $post->periode);

	$result = array(
	    'count' => $nb,
	);

	return new \Zend\View\Model\JsonModel($result);
    }

    /**
     * Sauvegarde du planning
     *
     * @return \Zend\View\Model\JsonModel
     * @throws \Exception
     */
    public function savePlanningAction() {
	// POST
	$post			 = $this->getRequest()
		->getPost();
	// Planning Table
	$tablePlanning		 = new \RHX\Model\Table\PlanningSemaineTable($this->getAdapter());
	$planning		 = $tablePlanning->get($post->id);
	$template		 = $planning->getTemplate();
	// Sauvegarde des données
	$prefixCode		 = $post->prefix . '_code';
	$prefixEntree		 = $post->prefix . '_entree';
	$prefixSortie		 = $post->prefix . '_sortie';
	$prefixPause		 = $post->prefix . '_pause';
	$prefixRepas		 = $post->prefix . '_repas';
	// Assignation des données
	$planning->$prefixCode	 = (int) $post->code;
	$planning->$prefixEntree = $post->entree;
	$planning->$prefixSortie = $post->sortie;
	$planning->$prefixPause	 = (int) $post->pause;
	$planning->$prefixRepas	 = (int) $post->repas;
	// Enregistrement
	$tablePlanning->save($planning);
	// Calcul des heures travaillées
	$calculator		 = new \RHX\Model\Object\XCalculator($this->getAdapter());
	// Calcul de la semaine entière
	$prefix			 = $post->prefix;
	// S'il s'agit d'un PRDA
	if ((int) $post->code == XRules::ProblemeRetardDepartAnticipe) {
	    $template->$prefixEntree = $post->refEntree;
	    $template->$prefixSortie = $post->refSortie;
	    $refEntree		 = $prefixEntree . '_ref';
	    $refSortie		 = $prefixSortie . '_ref';
	    $planning->$refEntree	 = $post->refEntree;
	    $planning->$refSortie	 = $post->refSortie;
	}
	$week			 = $calculator->calculateOneWeek($planning, $template, $planning->$prefix);
	$day			 = $week['day'];
	// Heures non planifiées
	$heureNonPlanifie	 = $calculator->getHeureNonPlannifie($planning->matricule, $planning->lundi);
	// Mise à jour des heures travaillés
	if ($calculator->updateHeureTravail($planning, $tablePlanning) == 0) {
	    throw new \Exception("Une erreur est survenue lors de la mise à jour des heures travaillées");
	}
	// Mise à jour des heures de retard
	$planning->retard	 = $week['nbPRDA'];
	$planning->retard_heure	 = $week['heurePRDA'];
	$tablePlanning->save($planning);
	//$calculator		 = new \RHX\Model\Object\XCalculator($this->getAdapter());
	$heureModulees		 = $calculator->getHeuresModulees($planning);

	$result = array(
	    'week'			 => $week,
	    'heureNonPlanifie'	 => $heureNonPlanifie,
	    'heurePRDA'		 => Number::frenchFormat(RHDateTime::toFloat($week['heurePRDA'])),
	    'nbPRDA'		 => $week['nbPRDA'],
	    'nonPlanifie'		 => $heureNonPlanifie['heureNonPlanifie'],
	    'day'			 => $day,
	    'planning'		 => $planning,
	    'template'		 => $template,
	    'heureModulees'		 => Number::frenchFormat(RHDateTime::toFloat($heureModulees->totalHours())),
	);

	return new \Zend\View\Model\JsonModel($result);
    }

    /**
     * Saugarde du planning édité
     * 
     * @return \Zend\View\Model\JsonModel
     */
    public function savePlanningAction_() {
	// Variable de retour
	$result = new \RHX\Model\Object\XData();

	// POST
	$post = $this->getRequest()
		->getPost();

	// Tables
	$planningSemaineTable	 = new \RHX\Model\Table\PlanningSemaineTable($this->getAdapter());
	$PSView			 = new \RHX\Model\View\PSPlanningView($this->getAdapter());

	// Planning
	$planning = $planningSemaineTable->get($post->id);

	// Règles
	$rules = new XRules($this->getAdapter());

	// Template
	$template = $PSView->getTemplate($planning->id, $planning->matricule);

	// Total des heures
	$totalHeure	 = new RHDateTime();
	$totalHeure->setTime();
	// Total des heures de Retard
	$retardHeure	 = new RHDateTime();
	$retardHeure->setTime();
	// Total des heures de Départ Anticipé
	$anticipeHeure	 = new RHDateTime();
	$anticipeHeure->setTime();
	// NOmbre de retard ou absence
	$nbPRDA		 = 0;

	/**
	 * Coefficient à appliquer pour la semaine
	 */
	$coef	 = 0.0;
	$now	 = new RHDateTime();
	$lundi	 = new RHDateTime($planning->lundi);
	if ($now->isGT($lundi)) {
	    // Le Planning Semaine en Question est antérieur à la date du jour ou est en cours de semaine
	    // Donc on utilise le planning déjà assigné au planning
	    $coef = floatval($planning->coef);
	    // Sinon, on utilise le coefficient en cours pour l'employé
	}

	// Assignation
	switch ($post->prefix) {

	    case 'lundi':
		$planning->lundi_code	 = $post->code;
		$planning->lundi_entree	 = $post->entree;
		$planning->lundi_sortie	 = $post->sortie;
		$planning->lundi_pause	 = $post->pause;
		$planning->lundi_repas	 = $post->repas;
		// Calcul
		$result			 = $rules->Calcul($planning->lundi_code, $planning->matricule, $planning->lundi_entree, $planning->lundi_sortie, $planning->lundi_pause, $planning->lundi_repas, $coef, $template->lundi_entree, $template->lundi_sortie, array());
		// Problème de Retard et de Départ Anticipé
		if ($result->retard || $result->anticipe) {
		    $nbPRDA++;
		    if ($result->retard) {
			$retardHeure->addHours($result->tempsRetard, false);
		    }
		    if ($result->anticipe) {
			$anticipeHeure->addHours($result->tempsAnticipe, false);
		    }
		}
		break;

	    case 'mardi':
		$planning->mardi_code	 = $post->code;
		$planning->mardi_entree	 = $post->entree;
		$planning->mardi_sortie	 = $post->sortie;
		$planning->mardi_pause	 = $post->pause;
		$planning->mardi_repas	 = $post->repas;
		// Calcul
		$result			 = $rules->Calcul($planning->mardi_code, $planning->matricule, $planning->mardi_entree, $planning->mardi_sortie, $planning->mardi_pause, $planning->mardi_repas, $coef, $template->mardi_entree, $template->mardi_sortie, array());
		// Problème de Retard et de Départ Anticipé
		if ($result->retard || $result->anticipe) {
		    $nbPRDA++;
		    if ($result->retard) {
			$retardHeure->addHours($result->tempsRetard, false);
		    }
		    if ($result->anticipe) {
			$anticipeHeure->addHours($result->tempsAnticipe, false);
		    }
		}
		break;

	    case 'mercredi':
		$planning->mercredi_code	 = $post->code;
		$planning->mercredi_entree	 = $post->entree;
		$planning->mercredi_sortie	 = $post->sortie;
		$planning->mercredi_pause	 = $post->pause;
		$planning->mercredi_repas	 = $post->repas;
		// Calcul
		$result				 = $rules->Calcul($planning->mercredi_code, $planning->matricule, $planning->mercredi_entree, $planning->mercredi_sortie, $planning->mercredi_pause, $planning->mercredi_repas, $coef, $template->mercredi_entree, $template->mercredi_sortie, array());
		// Problème de Retard et de Départ Anticipé
		if ($result->retard || $result->anticipe) {
		    $nbPRDA++;
		    if ($result->retard) {
			$retardHeure->addHours($result->tempsRetard, false);
		    }
		    if ($result->anticipe) {
			$anticipeHeure->addHours($result->tempsAnticipe, false);
		    }
		}
		break;

	    case 'jeudi':
		$planning->jeudi_code	 = $post->code;
		$planning->jeudi_entree	 = $post->entree;
		$planning->jeudi_sortie	 = $post->sortie;
		$planning->jeudi_pause	 = $post->pause;
		$planning->jeudi_repas	 = $post->repas;
		// Calcul
		$result			 = $rules->Calcul($planning->jeudi_code, $planning->matricule, $planning->jeudi_entree, $planning->jeudi_sortie, $planning->jeudi_pause, $planning->jeudi_repas, $coef, $template->jeudi_entree, $template->jeudi_sortie, array());
		// Problème de Retard et de Départ Anticipé
		if ($result->retard || $result->anticipe) {
		    $nbPRDA++;
		    if ($result->retard) {
			$retardHeure->addHours($result->tempsRetard, false);
		    }
		    if ($result->anticipe) {
			$anticipeHeure->addHours($result->tempsAnticipe, false);
		    }
		}
		break;

	    case 'vendredi':
		$planning->vendredi_code	 = $post->code;
		$planning->vendredi_entree	 = $post->entree;
		$planning->vendredi_sortie	 = $post->sortie;
		$planning->vendredi_pause	 = $post->pause;
		$planning->vendredi_repas	 = $post->repas;
		// Calcul
		$result				 = $rules->Calcul($planning->vendredi_code, $planning->matricule, $planning->vendredi_entree, $planning->vendredi_sortie, $planning->vendredi_pause, $planning->vendredi_repas, $coef, $template->vendredi_entree, $template->vendredi_sortie, array());
		// Problème de Retard et de Départ Anticipé
		if ($result->retard || $result->anticipe) {
		    $nbPRDA++;
		    if ($result->retard) {
			$retardHeure->addHours($result->tempsRetard, false);
		    }
		    if ($result->anticipe) {
			$anticipeHeure->addHours($result->tempsAnticipe, false);
		    }
		}
		break;

	    case 'samedi':
		$planning->samedi_code	 = $post->code;
		$planning->samedi_entree = $post->entree;
		$planning->samedi_sortie = $post->sortie;
		$planning->samedi_pause	 = $post->pause;
		$planning->samedi_repas	 = $post->repas;
		// Calcul
		$result			 = $rules->Calcul($planning->samedi_code, $planning->matricule, $planning->samedi_entree, $planning->samedi_sortie, $planning->samedi_pause, $planning->samedi_repas, $coef, $template->samedi_entree, $template->samedi_sortie, array());
		// Problème de Retard et de Départ Anticipé
		if ($result->retard || $result->anticipe) {
		    $nbPRDA++;
		    if ($result->retard) {
			$retardHeure->addHours($result->tempsRetard, false);
		    }
		    if ($result->anticipe) {
			$anticipeHeure->addHours($result->tempsAnticipe, false);
		    }
		}
		break;

	    case 'dimanche':
		$planning->dimanche_code	 = $post->code;
		$planning->dimanche_entree	 = $post->entree;
		$planning->dimanche_sortie	 = $post->sortie;
		$planning->dimanche_pause	 = $post->pause;
		$planning->dimanche_repas	 = $post->repas;
		// Calcul
		$result				 = $rules->Calcul($planning->dimanche_code, $planning->matricule, $planning->dimanche_entree, $planning->dimanche_sortie, $planning->dimanche_pause, $planning->dimanche_repas, $coef, $template->dimanche_entree, $template->dimanche_sortie, array());
		// Problème de Retard et de Départ Anticipé
		if ($result->retard || $result->anticipe) {
		    $nbPRDA++;
		    if ($result->retard) {
			$retardHeure->addHours($result->tempsRetard, false);
		    }
		    if ($result->anticipe) {
			$anticipeHeure->addHours($result->tempsAnticipe, false);
		    }
		}
		break;
	}

	// Total des heures travaillés de la semaine
	$resultDimanche	 = $rules->Calcul($planning->dimanche_code, $planning->matricule, $planning->dimanche_entree, $planning->dimanche_sortie, $planning->dimanche_pause, $planning->dimanche_repas, $coef, $template->dimanche_entree, $template->dimanche_sortie, array());
	$resultLundi	 = $rules->Calcul($planning->lundi_code, $planning->matricule, $planning->lundi_entree, $planning->lundi_sortie, $planning->lundi_pause, $planning->lundi_repas, $coef, $template->lundi_entree, $template->lundi_sortie, array());
	$resultMardi	 = $rules->Calcul($planning->mardi_code, $planning->matricule, $planning->mardi_entree, $planning->mardi_sortie, $planning->mardi_pause, $planning->mardi_repas, $coef, $template->mardi_entree, $template->mardi_sortie, array());
	$resultMercredi	 = $rules->Calcul($planning->mercredi_code, $planning->matricule, $planning->mercredi_entree, $planning->mercredi_sortie, $planning->mercredi_pause, $planning->mercredi_repas, $coef, $template->mercredi_entree, $template->mercredi_sortie, array());
	$resultJeudi	 = $rules->Calcul($planning->jeudi_code, $planning->matricule, $planning->jeudi_entree, $planning->jeudi_sortie, $planning->jeudi_pause, $planning->jeudi_repas, $coef, $template->jeudi_entree, $template->jeudi_sortie, array());
	$resultVendredi	 = $rules->Calcul($planning->vendredi_code, $planning->matricule, $planning->vendredi_entree, $planning->vendredi_sortie, $planning->vendredi_pause, $planning->vendredi_repas, $coef, $template->vendredi_entree, $template->vendredi_sortie, array());
	$resultSamedi	 = $rules->Calcul($planning->samedi_code, $planning->matricule, $planning->samedi_entree, $planning->samedi_sortie, $planning->samedi_pause, $planning->samedi_repas, $coef, $template->samedi_entree, $template->samedi_sortie, array());
	$totalHeure->addHours($resultLundi->tempsDiff, false);
	$totalHeure->addHours($resultMardi->tempsDiff, false);
	$totalHeure->addHours($resultMercredi->tempsDiff, false);
	$totalHeure->addHours($resultJeudi->tempsDiff, false);
	$totalHeure->addHours($resultVendredi->tempsDiff, false);
	$totalHeure->addHours($resultSamedi->tempsDiff, false);
	$totalHeure->addHours($resultDimanche->tempsDiff, false);

	$totalRetard = new RHDateTime();
	$totalRetard->setTime();
	$totalRetard->addHours($retardHeure->totalHours(), false);
	$totalRetard->addHours($anticipeHeure->totalHours(), false);

	/* Heure non plannifié */
	// Employé
	$employe		 = $planning->getEmploye();
	$avenant		 = $employe->getAvenant();
	$hebdo			 = floatval($avenant->hebdo);
	$totalH			 = $totalHeure->totalHours();
	$heure_non_plannifie	 = RHDateTime::toFloat($totalH) - $hebdo;

	// Mise à jour
	$planning->heure_travaille	 = RHDateTime::toFloat($totalH);
	$planning->heure_non_planifie	 = $heure_non_plannifie;
	$planning->retard_heure		 = $totalRetard->totalHours();
	$planning->retard		 = $nbPRDA;
	$id				 = $planningSemaineTable->save($planning);

	// Debug
	//$this->Debug("Resultat");
	//$this->Debug(json_encode($result));
	//$this->Debug("Planning");
	//$this->Debug(json_encode($planning));

	return new \Zend\View\Model\JsonModel(array(
	    'result'		 => $result,
	    'planning'		 => $planning,
	    'id'			 => $id,
	    'retardHeure'		 => RHDateTime::toTime(number_format(RHDateTime::toFloat($planning->retard_heure), 2, ',', ' ')),
	    'heureTravaille'	 => RHDateTime::toTime(number_format($planning->heure_travaille, 2, ',', ' ')),
	    /* 'heureNonPlannifie'	 => RHDateTime::toTime(number_format($planning->heure_non_planifie, 2, ',', ' ')), */
	    'heureNonPlannifie'	 => $employe->getHeureNonPlanifiePeriode($planning->lundi),
	));
    }

    /**
     * Récupérer un planning à partir d'une date et d'un matricule
     * 
     * @return \Zend\View\Model\JsonModel
     */
    public function getPlanningIdAction() {
	// Table Planning Semaine
	$planningTable = new \RHX\Model\Table\PlanningSemaineTable($this->getAdapter());

	// POST
	$post = $this->getRequest()
		->getPost();

	// Planning Semaine
	$planning = $planningTable->getPlanningByDay($post->date, $post->matricule);

	return new \Zend\View\Model\JsonModel(array(
	    'id'		 => $planning->id,
	    'planning'	 => $planning,
	));
    }

    /**
     * calcul des données sur une semaine
     * 
     * @return \Zend\View\Model\JsonModel
     */
    public function calculRowAction() {
	// POST
	$post		 = $this->getRequest()
		->getPost();
	// calculator
	$calculator	 = new \RHX\Model\Object\XCalculator($this->getAdapter());
	// Table planning
	$tablePlanning	 = new \RHX\Model\Table\PlanningSemaineTable($this->getAdapter());
	$planning	 = $tablePlanning->get($post->id);
	$template	 = $planning->getTemplate();
	$week		 = $calculator->calculateOneWeek($planning, $template, $planning->lundi);
	$hnp		 = $calculator->getHeureNonPlannifie($planning->matricule, $planning->lundi);

	return new \Zend\View\Model\JsonModel(array(
	    'total'			 => array(
		'heurePRDA'	 => Number::frenchFormat(RHDateTime::toFloat($planning->retard_heure)),
		'nbPRDA'	 => $planning->retard,
	    ),
	    'heureNonPlannifie'	 => $hnp['heureNonPlanifie'],
	    'week'			 => $week,
	));
    }

    /**
     * Afficher un popin pour les transfert
     * 
     * @return array
     */
    public function popinTransfertAction() {
	// Changement de layout
	$this->layout('layout/ajax');
	// post
	$post		 = $this->getRequest()
		->getPost();
	// variables
	$id		 = $post->id;
	// table
	$tableTransfert	 = new \RHX\Model\Table\TransfertTable($this->getAdapter());
	$transfert	 = $tableTransfert->get($id);
	$employe	 = $transfert->getEmploye();
	$manager	 = new \RHX\Model\Manager\TransfertManager($this->getAdapter());
	$others		 = $manager->getOtherTransfert($id);

	return array(
	    'transfert'	 => $transfert,
	    'employe'	 => $employe,
	    'others'	 => $others,
	);
    }

    /**
     * Nombre de transaction pour une date données
     * 
     * @param int $site
     * @param string $date
     * @return int
     */
    public function getNbTransaction($site, $date) {
	////echo "<pre>Site : $site, Date : $date</pre>";
	$adapter	 = $this->getServiceLocator()
		->get('Zend\Db\Adapter\Adapter');
	$sql		 = "SELECT COUNT(*) as nbTransaction FROM saleHead, store WHERE saleHead.idStore = store.idStore AND saleHead.canceled = 0 AND (saleHead.workerMeal = 0 OR saleHead.workerMeal is NULL) AND saleHead.orderDate = '$date' AND store.groupmentCode = $site";
	$result		 = $adapter->query($sql)
		->execute();
	$nbTransaction	 = 0;
	foreach ($result as $e) {
	    $nbTransaction = (int) $e['nbTransaction'];
	    break;
	}
//	echo "<pre>Requête : $sql</pre>";
//	\Zend\Debug\Debug::dump($nbTransaction, 'Nombre de transaction');
	return $nbTransaction;
    }
    
    
    /* Chiffre d'affaire pour une date donnée
     * 
     * @param int $site
     * @param string $date
     * @return 
     */
    
    public function getPrevisionCa($site, $date) {
        $adapter	 = $this->getServiceLocator()
		->get('Zend\Db\Adapter\Adapter');
	        
        $site = $site == 0 ? 999: $site;// site siège
                
        $dateTime = new RHDateTime($date);
        //premiers du mois
        $month = $dateTime->date('Y') .'-'. $dateTime->date('m'). '-1';
        
        $sql = "SELECT * FROM Budget2 
                    WHERE   month = '$month' 
                        AND idStore = (SELECT idStore AS id FROM store WHERE groupmentCode=$site )";
                
	$result = $adapter->query($sql)->execute()->current();        
        $prevCa = $result['totttc'];        
        return $prevCa ;
    }
    /*
    public function testAction(){
        $res = $this->getPrevisionCa(3, '2013-02-25');
        var_dump($res);        
        die;
    }*/

    /**
     * Nombre de transaction pour une date précise
     * 
     * @return \Zend\View\Model\JsonModel
     */
    public function nbTransactionAction() {
	// post
	$post = $this->getRequest()
		->getPost();

	$data = array(
	    'nbTransaction' => $this->getNbTransaction($post->site, $post->date),
	);

	return new \Zend\View\Model\JsonModel($data);
    }

    public function editPlanningAction() {
	// changement de layout
	//$this->layout('layout/ajax');
	// post
	$post		 = $this->getRequest()
		->getPost();
	// table planning semaine
	$tablePlanning	 = new \RHX\Model\Table\PlanningSemaineTable($this->getAdapter());
	// table employe
	$tableEmploye	 = new \RHX\Model\Table\EmployeTable($this->getAdapter());
	// liste des employes du site
	$employeList	 = $tableEmploye->getEmployesBySite($post->site_id);
	$employeId	 = array();
	// parcours de la liste des employés
	foreach ($employeList as $e) {
	    $employeId[] = $e->matricule;
	}
	// liste des plannings du site
	$plannings		 = $tablePlanning->getPlanningByEmploye($post->get('data-lundi'), $employeId);
	// Liste des transferts de la semaine
	$tableTransfert		 = new \RHX\Model\Table\TransfertTable($this->getAdapter());
	$date			 = new RHDateTime($post->get('data-lundi'));
	$dayNames		 = array(
	    'lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche',
	);
	$transfertEntrants	 = array(
	    'lundi'		 => array(), 'mardi'		 => array(), 'mercredi'	 => array(), 'jeudi'		 => array(), 'vendredi'	 => array(), 'samedi'	 => array(), 'dimanche'	 => array(),
	);
	$transfertSortants	 = array(
	    'lundi'		 => array(), 'mardi'		 => array(), 'mercredi'	 => array(), 'jeudi'		 => array(), 'vendredi'	 => array(), 'samedi'	 => array(), 'dimanche'	 => array(),
	);
	// chargement des transferts de toute la semaine
	for ($i = 0; $i < 7; $i++, $date->modify('next day')) {
	    $entrants	 = $tableTransfert->getTransfertOfOneDay($date->date(), $post->site_id, Transfert::Entrant);
	    $sortants	 = $tableTransfert->getTransfertOfOneDay($date->date(), $post->site_id, Transfert::Sortant);
	    // parcours des transferts
	    foreach ($entrants as $entrant) {
		$transfertEntrants[$dayNames[$i]][] = $entrant;
	    }
	    foreach ($sortants as $sortant) {
		$transfertSortants[$dayNames[$i]][] = $sortant;
	    }
	}
	// Groupement des transferts
	$TE = array();
	foreach ($dayNames as $day) {
	    $lastMatricule = 0;
	    foreach ($transfertEntrants[$day] as $te) {
		if ((int) $te->matricule == $lastMatricule) {
		    $TE[$te->matricule][$day] = $te;
		}
		else {
		    $TE[$te->matricule]		 = array(
			'lundi'		 => null, 'mardi'		 => null, 'mercredi'	 => null, 'jeudi'		 => null, 'vendredi'	 => null, 'samedi'	 => null, 'dimanche'	 => null,
		    );
		    $TE[$te->matricule][$day]	 = $te;
		}
		$lastmatricule = (int) $te->matricule;
	    }
	}
	$TS = array();
	foreach ($dayNames as $day) {
	    $lastMatricule = 0;
	    foreach ($transfertSortants as $ts) {
		if ((int) $ts->matricule == $lastMatricule) {
		    $TS[$ts->matricule][$day] = $ts;
		}
		else {
		    $TS[$ts->matricule]		 = array(
			'lundi'		 => null, 'mardi'		 => null, 'mercredi'	 => null, 'jeudi'		 => null, 'vendredi'	 => null, 'samedi'	 => null, 'dimanche'	 => null,
		    );
		    $TS[$ts->matricule][$day]	 = $ts;
		}
		$lastMatricule = (int) $ts->matricule;
	    }
	}

	// Code acitivite
	$tableCode	 = new \RHX\Model\Table\CodeActiviteTable(($this->getAdapter()));
	$codeList	 = $tableCode->getAll();
	$codes		 = array();
	$codec		 = array();
	$couleurs	 = array();
	foreach ($codeList as $code) {
	    $codes[]		 = $code;
	    $codec[$code->id]	 = $code->code;
	    $couleurs[$code->code]	 = $code->couleur;
	}

	// Traitement des jours à afficher
	$days = array(
	    'lundi'		 => ($post->lundi == 'on') ? true : false,
	    'mardi'		 => ($post->mardi == 'on') ? true : false,
	    'mercredi'	 => ($post->mercredi == 'on') ? true : false,
	    'jeudi'		 => ($post->jeudi == 'on') ? true : false,
	    'vendredi'	 => ($post->vendredi == 'on') ? true : false,
	    'samedi'	 => ($post->samedi == 'on') ? true : false,
	    'dimanche'	 => ($post->dimanche == 'on') ? true : false,
	);

	// Identification de la semaine
	$tableSemaine	 = new \RHX\Model\Table\SemaineTable($this->getAdapter());
	$data		 = $tableSemaine->getSemaineByDate($post->lundi);
	$semaine	 = new \RHX\Model\Object\Semaine($data);

	// Site en cours
	$tableSite	 = new \RHX\Model\Table\SiteTable($this->getAdapter());
	$site		 = $tableSite->get($post->site_id);

	return array(
	    'plannings'	 => $plannings,
	    'entrants'	 => $TE,
	    'sortants'	 => $TS,
	    'codes'		 => $codes,
	    'codec'		 => $codec,
	    'couleurs'	 => $couleurs,
	    'days'		 => $days,
	    'dayNames'	 => $dayNames,
	    'editable'	 => ((int) $post->editable == 1) ? true : false,
	    'dialiog'	 => ((int) $post->dialog == 1) ? true : false,
	    'semaine'	 => $semaine,
	    'adapter'	 => $this->getAdapter(),
	    'site'		 => $site,
	);
    }

    /**
     * Affichage du résumé
     * 
     * @return array
     */
    public function showResumeAction() {
	$this->layout('layout/ajax');
	$planningManager = new \RHX\Model\Manager\PlanningManager($this->getAdapter());
	$post		 = $this->getRequest()
		->getPost();
	$planning	 = $planningManager->getPlanning($post->id);
	return array(
	    'post'		 => $post,
	    'stats'		 => $planningManager->getWeekStat($planning),
	    'employe'	 => $planningManager->getEmploye($post->matricule),
	    'codec'		 => $planningManager->getCodec(),
	    'planning'	 => $planning,
	    'hnp' => $planningManager->getHNP($post->matricule, $post->lundi),
	);
    }

    /**
     * Effacer un planning semaine
     * 
     * @return \Zend\View\Model\JsonModel
     */
    public function deleteAction() {
	$this->layout('layout/ajax');
	$planningManager = new \RHX\Model\Manager\PlanningManager($this->getAdapter());
	$id		 = (int) $this->params()
			->fromRoute('id', 0);
	$site		 = (int) $this->params()
			->fromRoute('other1', 0);
	$result		 = $planningManager->delete($id, $site);

	return new \Zend\View\Model\JsonModel($result);
    }
    
    

    /* Mise à jour des planning Semaine
     * 
     * 
     */

    public function updatePlanningSemaineOldAction() {
	$this->layout('layout/ajax');

	//table         
	$planningSemaineTable	 = $this->getService('Table\PlanningSemaineTable');
	$periodeSemaineTable	 = $this->getService('Table\PeriodeSemaineTable');
	$periodeTable		 = $this->getService('Table\PeriodeTable');
	$employeTable		 = $this->getService('Table\EmployeTable');

	$employeTemplateTable = $this->getService('Table\EmployeTemplateTable');

	//vue
	$planningListView = $this->getService('View\PSPlanningView');
        
        // calculateur
        $calculator	 = new \RHX\Model\Object\XCalculator($this->getAdapter());
        
	//data post
	$post		 = $this->getRequest()->getPost();
	$matricule	 = (int) $post->get('matricule', null);
	//$matricule = 32; // id de test
	// periodes 
	$periodes = $periodeTable->getAll('id DESC');

	$site	 = $this->navigation->offsetGet('site');
	$siteId	 = $site->id;

	//l'employé
	$thisEmp = $matricule ? $employeTable->get($matricule) : null;

	$dateEntree	 = new RHDateTime($thisEmp->contrat_debut);
	$hasDateDepart	 = $thisEmp->contrat_fin != null && $thisEmp->contrat_fin !== '' && $thisEmp->contrat_fin !== '0000-00-00';
	$dateDepart	 = $hasDateDepart ? new RHDateTime($thisEmp->contrat_fin) : null;

	////echo 'date contrat : [' . $thisEmp->contrat_debut . ' :' .  $thisEmp->contrat_fin . '] <br>' ;
	foreach ($periodes as $periode) {
	    // Liste des Semaines d'une Période
	    $semaineList = $periodeSemaineTable->getSemainesByPeriode($periode->id, 'id desc');

	    print('-- ' . $periode->libelle . ' -------------------------------------- [' . $periode->debut . ' : ' . $periode->fin . ' ] ---------- <br>');

	    $periodeDebut	 = new RHDateTime($periode->debut);
	    $periodeFin	 = new RHDateTime($periode->fin);

	    if ($dateEntree->isGT($periodeFin)) { ////echo"  dateEntree > periodeFin <br>" ;
		$isChevauchePrd = FALSE;
	    }
	    else {
		if ($dateEntree->isBetween($periodeDebut, $periodeFin)) // dateEntree between (periodeDebut periodeFin
		    $isChevauchePrd = TRUE;
		else { //  $dateEntree < $periodeDebut
		    if (!$hasDateDepart)
			$isChevauchePrd	 = TRUE;
		    else
			$isChevauchePrd	 = ($dateDepart->isLT($periodeDebut) ) ? FALSE : TRUE;
		}
	    }

	    var_dump($thisEmp->contrat_debut . ' << ');
	    if ($isChevauchePrd) { // si periode contient un des dates du contrat : MAJ les lignes planning semaine
		print (" periode includes contrat date!<br>");
		foreach ($semaineList as $semaine) {
		    $lundi		 = $semaine->lundi;
		    $planSemEmploye	 = $planningSemaineTable->getByEmploye($matricule, $lundi);

		    print('semaine ' . $semaine->id . '[  lundi : ' . $lundi . '] | ');
		    print($planSemEmploye ? 'ps ' . $planSemEmploye->id . ' ' : ' ps vide '); // != null? $planSemEmploye->id : 'NOT') ;                    
		    // 'planning type' & 'planning type employe' de l'employe
		    $prdSemPlanningView	 = $planningListView->getOne($periode->id, $semaine->id, $siteId);
		    $templateId		 = (int) $prdSemPlanningView->template;
		    $employeTemplate	 = $employeTemplateTable->getEmployeTemplate($matricule, $templateId);
		    $dayWks			 = array('Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi', 'Dimanche');

		    if ($planSemEmploye) { // MAJ les planning semaine                    
			// BOUCLER LES JOUR DE LA SEMAINE
			// SI Jour < $dateEntree : ES
			// SI $dateEntree < Jour < $dateDepart                             
			//          SI deja rempli : laisser tel quel
			//          SINON :
			//                 à partir planning type
			// SI Jour > $dateDepart : ES
			///////////////////
			print(' -- CODE PS    -- { ');
			// boucle jour
			foreach ($dayWks as $i => $daywk) {
			    $dayWkTolower = strtolower($daywk);

			    $dayDate	 = 'date' . $daywk;
			    $$dayDate	 = new RHDateTime($planSemEmploye->$dayWkTolower);
			    $day_code	 = $dayWkTolower . '_code';
			    $dayEntree	 = $dayWkTolower . '_entree';
			    $daySortie	 = $dayWkTolower . '_sortie';
			    $dayPause	 = $dayWkTolower . '_pause';
			    $dayRepas	 = $dayWkTolower . '_repas';

			    if ($hasDateDepart) {
				$isJourInContrat = $$dayDate->isBetween($dateEntree, $dateDepart);
			    }
			    else {
				$isJourInContrat = $$dayDate->isGT($dateEntree) || $$dayDate->isEqual($dateEntree);
			    }
			    echo ($isJourInContrat ? 'IC    -' : 'HC - ');

			    // //echo $planSemEmploye->$day_code . ' <span style=\' font-size: 60%; color: blue;\'>PTE '. $employeTemplate->$day_code . '</span>' ;

			    if (!$isJourInContrat) { // CAS (21) si jr hors new periode 
				print(" <span style='background: #ffeeee;'> ToES </span>");
				$planSemEmploye->$day_code = XRules::EntreeSortie;
				$planSemEmploye->$dayEntree = '00:00';
				$planSemEmploye->$daySortie = '00:00';
				$planSemEmploye->$dayPause = 0;
				$planSemEmploye->$dayRepas = 0;
				$planningSemaineTable->save($planSemEmploye);
			    }
			    else { // CAS (22) dans la contrat 
				if ($planSemEmploye->$day_code != XRules::EntreeSortie) { // CAS (221)  jour pas vièrge : laisser tel quel
				    print( '</span>' . "<span style='background: #eeeeff;'> telquel </span>");
				    // nothing to save
				}
				else { // CAS (222) : recupérer info PT || disponibilité 
				    print( '</span>' . " <span style='background: #eeffee;'> ToPT " . $employeTemplate->$day_code . " </span>");

				    $planSemEmploye->$day_code = $employeTemplate->$day_code;

				    $planSemEmploye->$dayEntree	 = $employeTemplate->$dayEntree;
				    $planSemEmploye->$daySortie	 = $employeTemplate->$daySortie;
				    $planSemEmploye->$dayPause	 = $employeTemplate->$dayPause;
				    $planSemEmploye->$dayRepas	 = $employeTemplate->$dayRepas;

				    $planningSemaineTable->save($planSemEmploye);
				}
			    }
			    print(' | ');
			}
			print('}');
		    }
		    else {
			echo (" > NOTYET PS");
			$hasTpl = $employeTemplate ? true : false;
			echo( $hasTpl ? ' > TPL' : ' > NOTYETTPL');
                        
                        $planning = new \RHX\Model\Object\PlanningSemaine($planningSemaineTable->getAdapter());
			if ($hasTpl) {
			    foreach ($dayWks as $i => $daywk) {
				$day = strtolower($daywk);

				$dayCode	 = $day . '_code';
				$dayEntree	 = $day . '_entree';
				$daySortie	 = $day . '_sortie';
				$dayPause	 = $day . '_pause';
				$dayRepas	 = $day . '_repas';

				$planning->$day	 = $semaine->$day;
				$jour		 = new RHDateTime($planning->$day);

				$isDayBetween = ($dateEntree->isLT($jour) || $dateEntree->isEqual($jour) ) && (!$hasDateDepart || ($dateDepart->isGT($jour) || $dateDepart->isEqual($jour) ) );
				print($isDayBetween ? ' ch ' : ' notch');

				if ($isDayBetween) {
				    //si jour est entre la date d'entrée et de sortie et si, éventuellement, pas de date de depart => CODE TEMPLATE</pre>";                               
				    $planning->$dayCode	 = $employeTemplate->$dayCode;
				    $planning->$dayEntree	 = $employeTemplate->$dayEntree;
				    $planning->$daySortie	 = $employeTemplate->$daySortie;
				    $planning->$dayPause	 = $employeTemplate->$dayPause;
				    $planning->$dayRepas	 = $employeTemplate->$dayRepas;
				}
				else {
				    $planning->$dayCode	 = XRules::EntreeSortie;
				    $planning->$dayEntree	 = "00:00";
				    $planning->$daySortie	 = "00:00";
				    $planning->$dayPause	 = 0;
				    $planning->$dayRepas	 = 0;
				}
			    }
			    $planning->matricule	 = $matricule;
			    $idNewPlanning		 = $planningSemaineTable->save($planning);
			}
			else {/* nothing todo */
                                $dispo = $thisEmp->getDisponibilite();
                                
                                foreach ($dayWks as $i => $daywk) {
				$day = strtolower($daywk);

				$dayCode	 = $day . '_code';
				$dayEntree	 = $day . '_entree';
				$daySortie	 = $day . '_sortie';
				$dayPause	 = $day . '_pause';
				$dayRepas	 = $day . '_repas';

				$planning->$day	 = $semaine->$day;
				$jour		 = new RHDateTime($planning->$day);

				$isDayBetween = ($dateEntree->isLT($jour) || $dateEntree->isEqual($jour) ) && (!$hasDateDepart || ($dateDepart->isGT($jour) || $dateDepart->isEqual($jour) ) );
				print($isDayBetween ? ' ch ' : ' notch');

				if ($isDayBetween) {
				    //si jour est entre la date d'entrée et de sortie et si, éventuellement, pas de date de depart => CODE TEMPLATE</pre>";                               
				    $planning->$dayCode          = $dispo->$day;
				    $planning->$dayEntree	 = $dispo->$dayEntree;
				    $planning->$daySortie	 = $dispo->$daySortie;
				    $planning->$dayPause	 = $calculator->isPause($planning->$dayEntree, $planning->$daySortie);
				    $planning->$dayRepas	 = $calculator->isRepas($planning->$dayEntree, $planning->$daySortie);
				}
				else {
				    $planning->$dayCode	 = XRules::EntreeSortie;
				    $planning->$dayEntree	 = "00:00";
				    $planning->$daySortie	 = "00:00";
				    $planning->$dayPause	 = 0;
				    $planning->$dayRepas	 = 0;
				}
			    }
			    $planning->matricule	 = $matricule;
			    $idNewPlanning		 = $planningSemaineTable->save($planning);
			}
		    }
		    print('<br>');

		    // update prorata planning semaine
		    // reload planning 
		    $planSemEmploye = $planningSemaineTable->getByEmploye($matricule, $lundi);

		    if ($planSemEmploye) {
			foreach ($dayWks as $i => $daywk) {
			    $day	 = strtolower($daywk);
			    $dayCode = $day . '_code';

			    if ($planSemEmploye->$dayCode == XRules::EntreeSortie) {
				print('aaa');
				$calculator	 = new \RHX\Model\Object\XCalculator($this->getAdapter());
				$prorata	 = $calculator->prorataHeurePrevues($employeTemplate->heure_prevues, $day);

				if ($prorata['float'] < 0.0) {
				    $planSemEmploye->heure_prevues = $employeTemplate->heure_prevues;
				}
				else {
				    $planSemEmploye->heure_prevues = $prorata['time'];
				}
			    }
			} // end foreach

			print ("<span style='color: blue;'> heures prevus  " . $planSemEmploye->heure_prevues . '</span> <br>');
			$planningSemaineTable->save($planSemEmploye);
		    }
		}
	    }
	    else { // si contrat est hors du periode : effacer les planning semaines de l' employe
		// Parcours des semaines de la période
		foreach ($semaineList as $semaine) {
		    $lundi = $semaine->lundi;

		    print('semaine ' . $semaine->id . '[  lundi : ' . $lundi . '] | ');
		    //$planningSemaine = $planningSemaineTable->getPlanningByEmploye($lundi, $employeMatrArray);

		    $planSemEmploye = $planningSemaineTable->getByEmploye($matricule, $lundi);
		    //$planSemEmploye = $planningSemaineTable->getPlanningByEmploye($lundi, array($matricule));

		    print($planSemEmploye ? 'ps ' . $planSemEmploye->id : 'ps vide '); // != null? $planSemEmploye->id : 'NOT') ;

		    if ($planSemEmploye) { // effacer tous les planning semaine pour cet employé
			print (' effacer ce planning semaine ' . $planSemEmploye->id . ' <br>');
			$planningSemaineTable->erase($planSemEmploye->id);
		    }
		    print('<br>');
		}
	    } // end if 
	}
	//die;

	return array();
    }
    
     /* Mise à jour des planning Semaine
     * 
     * 
     */

    public function updatePlanningSemaineAction() {
        $manager = new \RHX\Model\Manager\PlanningManager($this->getAdapter());
        
	$this->layout('layout/ajax');

	$post		 = $this->getRequest()->getPost();
	$matricule	 = (int) $post->get('matricule', null);
	$site	 = $this->navigation->offsetGet('site');
        
        $manager->updatePlanningSemaines($matricule, $site->id);
        
	return array();
    }
    
    /**
     * Insertion Ideal
     * 
     * @return \Zend\View\Model\JsonModel
     */
    public function insertIdealAction(){
	$this->layout('layout/ajax');
	$manager = new \RHX\Model\Manager\PlanningManager($this->getAdapter());
	return $manager->insertIdeal($this->getPost());
    }
    
    /**
     * Mise à jour Ideal
     * 
     * @return \Zend\View\Model\JsonModel
     */
    public function updateIdealAction(){
	$this->layout('layout/ajax');
	$manager = new \RHX\Model\Manager\PlanningManager($this->getAdapter());
	return $manager->updateIdeal($this->getPost());
    }

    public function showAction(){
	$site = $this->params()
		->fromRoute('id', -99);
	$semaine = $this->params()
		->fromRoute('other1', 0);
	$periode = $this->params()
		->fromRoute('other2', 0);
	$tableSemaine = new \RHX\Model\Table\SemaineTable($this->getAdapter());
	$semaine = $tableSemaine->getSemaineByDate($date);
	$post = $this->getPost();
	$post->set('site', $site);
	$post->set('periode', $periode);
	$post->set('data-lundi', $semaine->lundi);
	$edit = new \Zend\View\Model\ViewModel($this->loadIndexAction());
	$edit->setTemplate('rhx/employe/edit.phtml');
	return $edit;
    }
    
    /**
     * Mise à jour du planning semaine du site
     * 
     * @return array
     */
    public function updateSitePlanningAction(){
	$manager = new \RHX\Model\Manager\PlanningManager($this->getAdapter());
	$post = $this->getPost();
	$site = $manager->getSite($post->site);
	$periodes = $manager->getPeriodesATester();
	$msg = array();
	foreach($periodes as $p){
	    $msg[] = $manager->updateOnePlanningSemaine($site, $p);
	}
	$this->layout('layout/ajax');
	return array(
	    'msg' => $msg,
	);
    }
}
